Se usó la API de Cloud Translation para traducir esta página.

Implementa una base de datos vectorial de Qdrant en GKE.

Autopilot estándar

En esta guía, se muestra cómo implementar un clúster de base de datos vectorial Qdrant 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 tradicionales, 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. Estas características hacen que Qdrant sea una opción adecuada para una variedad de aplicaciones, incluidas la red neuronal o la coincidencia basada en la semántica, la búsqueda por facetas y más. Qdrant funciona no solo como una base de datos vectorial sino también como un motor de búsqueda de similitud vectorial.

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 Qdrant en GKE.

Ventajas

Qdrant ofrece los siguientes beneficios:

Amplia gama 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.
Compatibilidad con contenedores y Kubernetes que permite la implementación y la administración en entornos modernos nativos de la nube.
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 costos de infraestructura y mejorar el rendimiento.

Objetivos

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

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

Arquitectura de implementación

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

Diagrama de arquitectura

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

Arquitectura de implementación de Qdrant

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

Puedes controlar cómo GKE distribuye los Pods entre los nodos gracias a la configuración de las reglas de afinidad de Pod necesarias y las restricciones de distribución de topología en el archivo de valores del gráfico de Helm.
Si una zona falla, GKE reprograma los Pods en nodos nuevos según la configuración recomendada.

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

Usa discos SSD regionales (StorageClass personalizadosregional-pd) para conservar datos. Recomendamos los discos SSD regionales para las bases de datos debido a su baja latencia y sus altas IOPS.
Todos los datos del disco se replican entre las zonas principal y secundaria de la región, lo que aumenta la tolerancia a posibles fallas de zonas.

Costos

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

Para obtener una estimación de costos en función del uso previsto, usa la calculadora de precios.

Es posible que los usuarios de Google Cloud nuevos cumplan con los requisitos para acceder a una prueba gratuita.

Cuando completes las tareas que se describen en este documento, podrás borrar los recursos que creaste para evitar que se te siga facturando. Para obtener más información, consulta Realiza una limpieza.

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

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

Si usas un proveedor de identidad externo (IdP), primero debes Acceder a la gcloud CLI 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 instalaste gcloud CLI anteriormente, asegúrate de tener la versión más reciente ejecutando gcloud components update.

Si usas un proveedor de identidad externo (IdP), primero debes Acceder a la gcloud CLI 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.

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:

Para los fines de este instructivo, usa la región us-central1 para crear tus recursos de implementación.
```
export PROJECT_ID=PROJECT_ID
export KUBERNETES_CLUSTER_PREFIX=qdrant
export REGION=us-central1
```
- Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

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 qdrant para comenzar a crear recursos de implementación:
```
cd kubernetes-engine-samples/databases/qdrant
```

Crea la infraestructura del clúster

En esta sección, se incluye la ejecución de una secuencia de comandos de Terraform para crear un clúster de GKE regional privado y con alta disponibilidad con el objetivo de implementar tu base de datos de Qdrant.

Puedes elegir implementar Qdrant usando 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 regional de Autopilot implementado en tres zonas diferentes.

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}

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

GOOGLE_OAUTH_ACCESS_TOKEN: Se reemplaza por un token de acceso recuperado por el comando gcloud auth print-access-token para autenticar 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 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 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}

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

GOOGLE_OAUTH_ACCESS_TOKEN se reemplaza por un token de acceso recuperado por 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 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 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 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 nuevo clúster de GKE:

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

Implementa la base de datos de Qdrant en tu clúster

En este instructivo, implementarás la base de datos Qdrant (en modo distribuido) y el operador de HA con estado en el clúster de GKE usando 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 del Qdrant.
Las tolerancias, las afinidades de nodos y las restricciones de distribución de topología se configuran para garantizar una distribución adecuada en 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 administrar los procesos de conmutación por error y garantizar una 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 y así implementar la base de datos de Qdrant, 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} \
    --location=${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.
Agrega el repositorio de gráficos de Helm de la base de datos de Qdrant para poder implementarlo en tu clúster de GKE:
```
helm repo add qdrant https://qdrant.github.io/qdrant-helm
```
Crea el 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

En el manifiesto de regional-pd.yaml, se 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 un ConfigMap de Kubernetes con una configuración de archivo adicional metrics y un clúster de Qdrant usando 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

En el manifiesto de metrics-cm.yaml, se describe el archivo adicional ConfigMap de metrics:

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

En el manifiesto values.yaml, se 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 establecer un clúster de Qdrant con alta disponibilidad y distribuido.

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

En el manifiesto de ilb.yaml, se describe el Service 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

Verifica el estado de la implementación:

helm ls -n qdrant

Si la base de datos qdrant se implementó de forma correcta, el resultado es 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 requeridas:
```
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, verifica que GKE haya creado las cargas de trabajo de Qdrant:
```
kubectl get pod,svc,statefulset,pdb,secret -n qdrant
```
Inicia el recurso HighAvailabilityApplication (HAA) para 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
```
Los siguientes recursos de GKE se crean para el clúster de Qdrant:
- El StatefulSet del Qdrant que controla tres réplicas de Pod.
- A PodDisruptionBudget, lo que garantiza un máximo de 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 servicio qdrant-database-headless, que proporciona la lista de pods de Qdrant en ejecución.
- El secreto qdrant-database-apikey, que facilita una conexión segura de la base de datos.
- Pod de operador de HA con estado y recurso HighlyAvailableApplication, que supervisa de forma activa la aplicación de Qdrant. El recurso HighlyAvailableApplication define reglas de conmutación por error que se aplicarán en Qdrant.

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 qdrant-database -n qdrant

El resultado es similar a lo siguiente:

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

Ejecuta consultas con el notebook de Vertex AI Colab Enterprise

Qdrant organiza vectores y cargas útiles en colecciones. La incorporación vectorial es una técnica que representa palabras o entidades como vectores numéricos mientras mantienen sus relaciones semánticas. Esto es importante para las búsquedas de similitud, ya que permite encontrar similitudes basadas en el significado en lugar de en las coincidencias exactas, lo que hace que las 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 colección nueva de Qdrant y ejecutar búsquedas.

En este ejemplo, se usa un conjunto de datos de un archivo CSV que contiene una lista de libros de diferentes géneros. Creas un notebook de Colab Enterprise para realizar una 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.

Crea una plantilla de entorno de ejecución

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

En la consola de Google Cloud , ve a la página Plantillas de entorno 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 New Template. Aparecerá la página Crear nueva plantilla de entorno de ejecución.
En la sección Conceptos básicos del entorno de ejecución, haz lo siguiente:
- En el campo Nombre visible, escribe 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 procesamiento, haz lo siguiente:
- En la lista desplegable Tipo de máquina, selecciona e2-standard-2.
- En el campo Tamaño del disco, ingresa 30.
En la sección Herramientas de redes y seguridad, haz lo siguiente:
- En la lista desplegable Red, selecciona la red en la que reside tu clúster de GKE.
- En la lista desplegable Subred, selecciona una subred correspondiente.
- Desmarca la casilla de verificación Habilitar el acceso a Internet pública.
Para terminar de crear la plantilla de entorno de ejecución, haz clic en Crear. Tu plantilla de entorno de ejecución aparece en la lista en la pestaña Plantillas de entorno de ejecución.

Crea un entorno de ejecución

Para crear un entorno de ejecución de Colab Enterprise, haz lo siguiente:

En la lista de plantillas de ejecución de la plantilla que acabas de crear, en la columna Acciones, haz clic en y, luego, en Crear tiempo de ejecución. Aparecerá el panel Crear entorno de ejecución de Vertex AI.
Para crear un entorno 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.

Importa el notebook

Para importar el notebook en Colab Enterprise, haz lo siguiente:

Ve a la pestaña Mis notebooks y haz clic en Importar. Aparecerá el panel Import notebooks.
En Fuente de importación, selecciona URL.

En URLs de notebooks, ingresa el siguiente vínculo:

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

Haz clic en Importar.

Conéctate al entorno de ejecución y ejecuta consultas

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

En el notebook, junto al botón Conectar, haz clic en Opciones de conexión adicionales. Aparecerá el panel Conéctate al entorno de ejecución de Vertex AI.
Selecciona Conectar a un entorno de ejecución y, luego, Conectar a un entorno de ejecución existente.
Selecciona el entorno de ejecución que iniciaste y haz clic en Conectar.
Para ejecutar las celdas del notebook, haz clic en el botón Ejecutar celda junto a cada celda de código.

El notebook contiene celdas de código y texto que describen cada bloque de código. Cuando se ejecuta una celda de código, se ejecutan sus comandos y se muestra un resultado. Puedes ejecutar las celdas en orden o ejecutar celdas individuales según sea necesario.

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 de 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 del Qdrant que exponen las métricas en la ruta / y el puerto 80. El contenedor de archivo adicional llamado metrics proporciona estas métricas.
Recopiladores 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 extraer 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 Cloud Monitoring con la configuración definida 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 Qdrant 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:
- Colecciones
- Vectores incorporados
- Operaciones pendientes
- Ejecución de nodos

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 volúmenes, 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 serían las siguientes: Se borran automáticamente.

Para configurar los planes de copia de seguridad, sigue estos pasos:

Habilita la función de copia de seguridad para 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 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: [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 que se completa la ejecución, el resultado es similar al siguiente:

Created backup plan [qdrant-cluster-backup].

Puedes ver el plan de copia de seguridad recién creado qdrant-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.

Libera espacio

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 el contenido. 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 IDs personalizados de los proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID personalizado del proyecto que desees utilizar en el futuro. Para conservar las URLs que usan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto, en lugar de todo el proyecto.

Si planeas explorar varios instructivos, arquitecturas o guías de inicio rápido, reutilizar proyectos puede ser útil para no exceder los límites de cuota de los proyectos.

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

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 Qdrant en el mercado de GKE.
Explora el software de código abierto de Qdrant.
Prueba laOperador Qdrant que ofrece Administración de claves de API, compatibilidad con TLS con administración de certificados y programación de copias de seguridad.
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.

Implementa una base de datos vectorial de Qdrant en GKE. Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Ventajas

Objetivos

Arquitectura de implementación

Diagrama de arquitectura

Costos

Antes de comenzar

Configura tu entorno

Crea la infraestructura del clúster

Autopilot

Estándar

Conéctate al clúster

Implementa la base de datos de Qdrant en tu clúster

Autopilot

Estándar

Ejecuta consultas con el notebook de Vertex AI Colab Enterprise

Crea una plantilla de entorno de ejecución

Crea un entorno de ejecución

Importa el notebook

Conéctate al entorno de ejecución y ejecuta consultas

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

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

Libera espacio

Borra el proyecto

Borra los recursos individuales

¿Qué sigue?

Implementa una base de datos vectorial de Qdrant en GKE.