Qdrant-Vektordatenbank in GKE bereitstellen


In dieser Anleitung wird beschrieben, wie Sie einen Qdrant-Vektordatenbankcluster in Google Kubernetes Engine (GKE) bereitstellen.

Vektordatenbanken sind Datenspeicher, die speziell für die Verwaltung und Suche in großen Sammlungen von hochdimensionalen Vektoren entwickelt wurden. Diese Vektoren stellen Daten wie Text, Bilder, Audio, Video oder alle Daten dar, die numerisch codiert werden können. Im Gegensatz zu traditionellen Datenbanken, die auf genaue Übereinstimmungen beruhen, sind Vektordatenbanken auf die Suche nach ähnlichen Elementen oder das Identifizieren von Mustern in umfangreichen Datasets spezialisiert. Diese Eigenschaften machen Qdrant zu einer geeigneten Wahl für eine Vielzahl von Anwendungen, einschließlich neuronaler Netzwerke oder semantischer Übereinstimmung, Facettensuche und mehr. Qdrant dient nicht nur als Vektordatenbank, sondern auch als Suchmaschine für Vektorähnlichkeiten.

Diese Anleitung richtet sich an Cloud Platform-Administratoren und -Architekten, ML-Entwickler und MLOps-Experten (DevOps), die an der Bereitstellung von Qdrant-Datenbankclustern auf GKE interessiert sind.

Vorteile

Qdrant bietet folgende Vorteile:

  • Eine Vielzahl von Bibliotheken für verschiedene Programmiersprachen und eine offene API zur Einbindung in andere Dienste.
  • Horizontale Skalierung und Unterstützung für Fragmentierung und Replikation, die Skalierung und Hochverfügbarkeit vereinfacht.
  • Container- und Kubernetes-Unterstützung, die die Bereitstellung und Verwaltung in modernen cloudnativen Umgebungen ermöglicht.
  • Flexible Nutzlasten mit erweiterter Filterung für eine präzise Anpassung der Suchkriterien.
  • Verschiedene Quantisierungsoptionen und andere Optimierungen, um die Infrastrukturkosten zu senken und die Leistung zu verbessern.

Lernziele

In dieser Anleitung erfahren Sie mehr über die folgenden Themen:

  • GKE-Infrastruktur für Qdrant planen und bereitstellen.
  • Stellen Sie den Operator StatefulHA bereit, um für Qdrant eine Hochverfügbarkeit zu gewährleisten.
  • Stellen Sie den Qdrant-Cluster bereit und konfigurieren Sie ihn.
  • Demo-Dataset hochladen und Suchanfrage ausführen.
  • Messwerte erfassen und Dashboard ausführen

Bereitstellungsarchitektur

Diese Architektur richtet einen fehlertoleranten, skalierbaren GKE-Cluster für Qdrant in mehreren Verfügbarkeitszonen ein. Dadurch wird die Betriebszeit und Verfügbarkeit mit Rolling Updates und minimalen Störungen sichergestellt. Dazu gehört die Verwendung des zustandsorientierten HA-Operators zur effizienten Failover-Verwaltung. Weitere Informationen finden Sie unter Regionale Cluster.

Architekturdiagramm

Das folgende Diagramm zeigt einen Qdrant-Cluster, der auf mehreren Knoten und Zonen in einem GKE-Cluster ausgeführt wird:

Bereitstellungsarchitektur von Qdrant

In dieser Architektur wird das Qdrant-StatefulSet auf drei Knoten in drei verschiedenen Zonen bereitgestellt.

Für die Datenpersistenz hat die Architektur in dieser Anleitung folgende Merkmale:

  • Dabei werden regionale SSD-Laufwerke (benutzerdefinierte regional-pd StorageClass) zur Speicherung von Daten verwendet. Wir empfehlen regionale SSD-Laufwerke für Datenbanken aufgrund ihrer geringen Latenz und hohen IOPS.
  • Alle Laufwerksdaten werden zwischen primären und sekundären Zonen in der Region repliziert, wodurch die Toleranz für potenzielle Zonenausfälle erhöht wird.

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweise

In dieser Anleitung verwenden Sie Cloud Shell zum Ausführen von Befehlen. Cloud Shell ist eine Shell-Umgebung für die Verwaltung von Ressourcen, die in Google Cloud gehostet werden. Es ist bei Google Cloud CLI, kubectl, Helm und Terraform-Befehlszeilentools vorinstalliert. Wenn Sie Cloud Shell nicht verwenden, müssen Sie die Google Cloud CLI installieren.

  1. 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.
  2. Install the Google Cloud CLI.
  3. To initialize the gcloud CLI, run the following command:

    gcloud init
  4. Create or select a Google Cloud project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

  5. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

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

    gcloud services enable cloudresourcemanager.googleapis.com compute.googleapis.com container.googleapis.com iamcredentials.googleapis.com gkebackup.googleapis.com
  7. Install the Google Cloud CLI.
  8. To initialize the gcloud CLI, run the following command:

    gcloud init
  9. Create or select a Google Cloud project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

  10. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

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

    gcloud services enable cloudresourcemanager.googleapis.com compute.googleapis.com container.googleapis.com iamcredentials.googleapis.com gkebackup.googleapis.com
  12. Grant roles to your user account. Run the following command once for each of the following IAM roles: role/storage.objectViewer, roles/container.admin, roles/iam.serviceAccountAdmin, roles/compute.admin, roles/gkebackup.admin, roles/monitoring.viewer

    gcloud projects add-iam-policy-binding PROJECT_ID --member="USER_IDENTIFIER" --role=ROLE
    • Replace PROJECT_ID with your project ID.
    • Replace USER_IDENTIFIER with the identifier for your user account. For example, user:myemail@example.com.

    • Replace ROLE with each individual role.

Umgebung einrichten

So richten Sie Ihre Umgebung mit Cloud Shell ein:

  1. Legen Sie Umgebungsvariablen für Ihr Projekt, Ihre Region und ein Kubernetes-Clusterressourcenpräfix fest:

    Für diese Anleitung verwenden Sie die Region us-central1, um Ihre Bereitstellungsressourcen zu erstellen.

    export PROJECT_ID=PROJECT_ID
    export KUBERNETES_CLUSTER_PREFIX=qdrant
    export REGION=us-central1
    
    • Ersetzen Sie PROJECT_ID durch die Google Cloud-Projekt-ID.
  2. Prüfen Sie die Helm-Version:

    helm version
    

    Aktualisieren Sie die Version, wenn sie älter als 3.13 ist:

    curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
    
  3. Klonen Sie das Beispielcode-Repository aus GitHub:

    git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
    
  4. Wechseln Sie in das Verzeichnis qdrant, um mit dem Erstellen der Bereitstellungsressourcen zu beginnen:

    cd kubernetes-engine-samples/databases/qdrant
    

Clusterinfrastruktur erstellen

In diesem Abschnitt wird ein Terraform-Skript ausgeführt, um einen privaten, hochverfügbaren regionalen GKE-Cluster zum Bereitstellen Ihrer Qdrant-Datenbank zu erstellen.

Sie können Qdrant mit einem Standard- oder Autopilot-Cluster bereitstellen. Jede hat ihre eigenen Vorteile und unterschiedliche Preismodelle.

Autopilot

Das folgende Diagramm zeigt einen regionalen Autopilot-GKE-Cluster, der in drei verschiedenen Zonen bereitgestellt wird.

GKE Autopilot-Cluster

Führen Sie die folgenden Befehle in der Cloud Shell aus, um die Clusterinfrastruktur bereitzustellen:

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}

Die folgenden Variablen werden zur Laufzeit ersetzt:

  • GOOGLE_OAUTH_ACCESS_TOKEN: Ersetzt durch ein Zugriffstoken, das mit dem Befehl gcloud auth print-access-token abgerufen wird, um Interaktionen mit verschiedenen Google Cloud APIs zu authentifizieren.
  • PROJECT_ID, REGION und KUBERNETES_CLUSTER_PREFIX sind die im Abschnitt Umgebung einrichten definierten Umgebungsvariablen und den neuen relevanten Variablen für den Autopilot-Cluster zugewiesen, den Sie erstellen.

Geben Sie bei Aufforderung yes ein.

Die Ausgabe sieht in etwa so aus:

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

Outputs:

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

Terraform erstellt die folgenden Ressourcen:

  • Ein benutzerdefiniertes VPC-Netzwerk und ein privates Subnetz für die Kubernetes-Knoten
  • Ein Cloud Router für den Zugriff auf das Internet über Network Address Translation (NAT).
  • Ein privater GKE-Cluster in der Region us-central1.
  • Ein ServiceAccount mit Logging- und Monitoring-Berechtigungen für den Cluster.
  • Google Cloud Managed Service for Prometheus-Konfiguration für Clustermonitoring und Benachrichtigungen.

Standard

Das folgende Diagramm zeigt einen privaten Standard-GKE-Cluster, der in drei verschiedenen Zonen bereitgestellt wird.

GKE-Standardcluster

Führen Sie die folgenden Befehle in der Cloud Shell aus, um die Clusterinfrastruktur bereitzustellen:

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}

Die folgenden Variablen werden zur Laufzeit ersetzt:

  • GOOGLE_OAUTH_ACCESS_TOKEN wird durch ein Zugriffstoken ersetzt, das mit dem Befehl gcloud auth print-access-token abgerufen wird, um Interaktionen mit verschiedenen Google Cloud APIs zu authentifizieren.
  • PROJECT_ID, REGION und KUBERNETES_CLUSTER_PREFIX sind die im Abschnitt Umgebung einrichten definierten Umgebungsvariablen und den neuen relevanten Variablen für den Standard-Cluster zugewiesen, den Sie erstellen.

Geben Sie bei Aufforderung yes ein. Es kann einige Minuten dauern, bis diese Befehle abgeschlossen sind und der Cluster den Status „Bereit“ anzeigt.

Die Ausgabe sieht in etwa so aus:

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

Outputs:

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

Terraform erstellt die folgenden Ressourcen:

  • Ein benutzerdefiniertes VPC-Netzwerk und ein privates Subnetz für die Kubernetes-Knoten
  • Ein Cloud Router für den Zugriff auf das Internet über Network Address Translation (NAT).
  • Ein privater GKE-Cluster in der Region us-central1 mit aktiviertem Autoscaling (ein bis zwei Knoten pro Zone).
  • Ein ServiceAccount mit Logging- und Monitoring-Berechtigungen für den Cluster.
  • Google Cloud Managed Service for Prometheus-Konfiguration für Clustermonitoring und Benachrichtigungen.

Mit dem Cluster verbinden

Konfigurieren Sie kubectl so, dass Anmeldedaten abgerufen und mit Ihrem neuen GKE-Cluster kommuniziert wird:

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

Qdrant-Datenbank in Ihrem Cluster bereitstellen

In dieser Anleitung stellen Sie die Qdrant-Datenbank (im verteilten Modus) und den zustandsorientierten HA-Operator mithilfe des Helm-Diagramms auf Ihrem GKE-Cluster bereit.

Das Deployment erstellt einen GKE-Cluster mit der folgenden Konfiguration:

  • Drei Replikate der Qdrant-Knoten.
  • Toleranzen, Knotenaffinitäten und Topologieverteilungseinschränkungen werden für eine ordnungsgemäße Verteilung auf Kubernetes-Knoten konfiguriert. Dadurch werden die Knotenpools und verschiedenen Verfügbarkeitszonen genutzt.
  • Ein RePD-Volume mit dem SSD-Laufwerkstyp wird zur Datenspeicherung bereitgestellt.
  • Ein zustandsorientierter HA-Operator wird verwendet, um Failover-Prozesse zu verwalten und eine hohe Verfügbarkeit zu gewährleisten.
  • Zur Authentifizierung erstellt die Datenbank ein Kubernetes-Secret, das den API-Schlüssel enthält.

So verwenden Sie das Helm-Diagramm, um die Qdrant-Datenbank bereitzustellen:

  1. StatefulHA-Add-on aktivieren:

    Autopilot

    GKE aktiviert das Add-on StatefulHA bei der Clustererstellung automatisch.

    Standard

    Führen Sie dazu diesen Befehl aus:

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

    Es kann 15 Minuten dauern, bis dieser Befehl abgeschlossen ist und der Cluster den Status „Bereit“ anzeigt.

  2. Fügen Sie das Helm-Diagramm-Repository der Qdrant-Datenbank hinzu, bevor Sie es in Ihrem GKE-Cluster bereitstellen können:

    helm repo add qdrant https://qdrant.github.io/qdrant-helm
    
  3. Erstellen Sie den Namespace qdrant für die Datenbank:

    kubectl create ns qdrant
    
  4. Wenden Sie das Manifest an, um einen regionalen nichtflüchtigen SSD-Speicher StorageClass zu erstellen:

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

    Das Manifest regional-pd.yaml beschreibt den nichtflüchtigen SSD-Speicher 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. Stellen Sie mithilfe von Helm eine Kubernetes-Configmap mit einer metrics-Sidecar-Konfiguration und einem Qdrant-Cluster bereit:

    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
    

    Das metrics-cm.yaml-Manifest beschreibt die metrics-Sidecar-Datei 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;
          }
        }

    Das Manifest values.yaml beschreibt die Qdrant-Clusterkonfiguration :

    replicaCount: 3
    
    config:
      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.26
        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 

    Diese Konfiguration aktiviert den Clustermodus, sodass Sie einen hochverfügbaren und verteilten Qdrant-Cluster einrichten können.

  6. Prüfen Sie den Bereitstellungsstatus:

    helm ls -n qdrant
    

    Wenn die qdrant-Datenbank erfolgreich bereitgestellt wurde, sieht die Ausgabe in etwa so aus:

    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
    
  7. Warten Sie, bis GKE die erforderlichen Arbeitslasten gestartet hat:

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

    Die Verarbeitung dieses Befehls kann einige Minuten dauern.

  8. Prüfen Sie, nachdem GKE die Arbeitslasten gestartet hat, ob GKE die Qdrant-Arbeitslasten erstellt hat:

    kubectl get pod,svc,statefulset,pdb,secret -n qdrant
    
  9. Starten Sie die HighAvailabilityApplication-Ressource (HAA) für Qdrant:

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

    Das ha-app.yaml-Manifest beschreibt die HighAvailabilityApplication-Ressource:

    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

    Die folgenden GKE-Ressourcen werden für den Qdrant-Cluster erstellt:

    • Die Qdrant-StatefulSet, die drei Pod-Replikate steuert.
    • A PodDisruptionBudget, wobei maximal ein nicht verfügbares Replikat möglich ist.
    • Der qdrant-database-Dienst, der den Qdrant-Port für eingehende Verbindungen und Replikation zwischen Knoten verfügbar macht.
    • Der qdrant-database-headless-Dienst, der die Liste der ausgeführten Qdrant-Pods bereitstellt.
    • Das Secret qdrant-database-apikey, das eine sichere Datenbankverbindung ermöglicht.
    • Zustandsorientierter HA-Operator-Pod und HighlyAvailableApplication-Ressource, die die Qdrant-Anwendung aktiv überwachen. Die Ressource HighlyAvailableApplication definiert Failover-Regeln, die auf Qdrant angewendet werden.
  10. Wenn Sie prüfen möchten, ob die Failover-Regeln angewendet werden, beschreiben Sie die Ressource und bestätigen Sie Status: Message: Application is protected.

    kubectl describe highavailabilityapplication qdrant-database -n qdrant
    

    Die Ausgabe sieht in etwa so aus:

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

Dataset hochladen und Suchanfragen mit Jupyter Notebook ausführen

Qdrant organisiert Vektoren und Nutzlasten in Sammlungen. Die Vektoreinbettung ist eine Technik, bei der Wörter oder Entitäten als numerische Vektoren dargestellt werden, wobei ihre semantischen Beziehungen beibehalten werden. Dies ist für Ähnlichkeitssuchen wichtig, da es das Finden von Ähnlichkeiten anhand von Bedeutung statt exakter Übereinstimmungen ermöglicht. Aufgaben wie Such- und Empfehlungssysteme werden dadurch effektiver und differenzierter.

In diesem Abschnitt erfahren Sie, wie Sie Vektoren in eine neue Qdrant-Sammlung hochladen und einfache Suchanfragen ausführen.

In diesem Beispiel verwenden Sie ein Dataset aus einer CSV-Datei, die eine Liste von Büchern verschiedener Genres enthält. Qdrant dient als Suchmaschine und der von Ihnen erstellte Jupyter-Notebook-Pod dient als Client, der die Qdrant-Datenbank abfragt.

  1. Erstellen Sie die ConfigMaps books-dataset und demo-app und stellen Sie das Jupyter-Notebook bereit:

    kubectl create -n qdrant configmap books-dataset --from-file=manifests/04-notebook/dataset.csv
    kubectl create -n qdrant configmap notebook --from-file=manifests/04-notebook/vector-database.ipynb
    kubectl apply -n qdrant -f manifests/04-notebook/jupyter.yaml
    
    • Das zuvor erstellte Secret mit dem Namen qdrant-apikey wird im Client-Pod als Umgebungsvariable namens APIKEY bereitgestellt.
    • Die ConfigMap books-dataset enthält eine csv-Datei mit Buchdaten für die Qdrant-Sammlung
    • Die ConfigMap notebook enthält das Jupyter-Notebook zum Erstellen der Qdrant-Sammlung aus books-dataset.

  2. Warten Sie, bis GKE den Jupyter-Pod gestartet hat:

    kubectl wait pods -l app=jupyter-notebook --for condition=Ready --timeout=300s -n qdrant
    
  3. Öffnen Sie diese URL und klicken Sie auf die Datei vector-database.ipynb. Klicken Sie auf „Ausführen“ -> „Alle Zellen ausführen“. Jupyter führt den gesamten Code aus und führt eine Suchanfrage durch.

    Diese Abfrage führt eine semantische Suche in Ihrer my_books-Sammlung in Qdrant aus und ruft maximal zwei Ergebnisse mit dem höchsten Übereinstimmungswert ab, der für Ihren Abfragetext relevant ist.

    Dann wird jedes Ergebnis ausgegeben, getrennt durch eine Zeile von Bindestrichen im folgenden Format :

    • Title: Titel des Buchs
    • Author: Autor des Buchs
    • Description: Wie im Metadatenfeld description Ihres Dokuments gespeichert
    • Published: Erscheinungsdatum des Buchs
    • Score: Relevanzbewertung von Qdrant

    Die Ausgabe sieht in etwa so aus:

    Title: Romeo and Juliet
    Author: William Shakespeare, Paul Werstine (Editor), Barbara A. Mowat (Editor),
    Paavo Emil Cajander (Translator)
    Description: In Romeo and Juliet, Shakespeare creates a violent world, in which
    two young people fall in love. It is not simply that their families disapprove;
    the Montagues and the Capulets are engaged in a blood feud.In this death-filled
    setting, the movement from love at first sight to the lovers' final union in
    death seems almost inevitable. And yet, this play set in an extraordinary world
    has become the quintessential story of young love. In part because of its exquisite
    language, it is easy to respond as if it were about all young lovers. Published: 01/01/04
    Score: 0.8935013
    -----
    Title: The Unbearable Lightness of Being
    Author: Milan Kundera, Michael Henry Heim (Translator)
    Description: In The Unbearable Lightness of Being, Milan Kundera tells the story
    of a young woman in love with a man torn between his love for her and his incorrigible
    womanizing and one of his mistresses and her humbly faithful lover. This magnificent
    novel juxtaposes geographically distant places, brilliant and playful reflections,
    and a variety of styles, to take its place as perhaps the major achievement of
    one of the world's truly great writers. Published: 10/27/09
    Score: 0.8931863
    -----
    

Prometheus-Messwerte für Ihren Cluster aufrufen

Der GKE-Cluster wird mit Google Cloud Managed Service for Prometheus konfiguriert, der die Erfassung von Messwerten im Prometheus-Format ermöglicht. Dieser Dienst bietet eine vollständig verwaltete Lösung für Monitoring und Benachrichtigungen, die die Erfassung, Speicherung und Analyse von Messwerten aus dem Cluster und seinen Anwendungen ermöglicht.

Das folgende Diagramm zeigt, wie Prometheus Messwerte für Ihren Cluster erfasst:

Prometheus-Messwerterfassung

Der private GKE-Cluster im Diagramm enthält die folgenden Komponenten:

  • Qdrant-Pods, die Messwerte für den Pfad / und den Port 80 verfügbar machen. Diese Messwerte werden vom Sidecar-Container namens metrics bereitgestellt.
  • Prometheus-basierte Collectors, die die Messwerte aus den Qdrant-Pods verarbeiten.
  • Eine PodMonitoring-Ressource, die Messwerte an Cloud Monitoring sendet.

So exportieren Sie die Messwerte und zeigen sie an:

  1. Erstellen Sie die PodMonitoring-Ressource, um Messwerte nach labelSelector zu extrahieren:

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

    Das pod-monitoring.yaml-Manifest beschreibt die PodMonitoring-Ressource:

    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. Erstellen Sie ein Cloud Monitoring-Dashboard mit den in dashboard.json definierten Konfigurationen :

    gcloud --project "${PROJECT_ID}" monitoring dashboards create --config-from-file monitoring/dashboard.json
    
  3. Nachdem der Befehl erfolgreich ausgeführt wurde, rufen Sie die Cloud Monitoring-Dashboards auf:

    Zur Dashboard-Übersicht

  4. Öffnen Sie in der Liste der Dashboards das Qdrant Overview-Dashboard. Es kann ein bis zwei Minuten dauern, bis Messwerte erfasst und angezeigt werden.

    Im Dashboard wird die Anzahl der wichtigsten Messwerte angezeigt:

    • Sammlungen
    • Eingebettete Vektoren
    • Ausstehende Vorgänge
    • Laufende Knoten

Clusterkonfiguration sichern

Mit dem Feature Sicherung für GKE können Sie regelmäßige Sicherungen Ihrer gesamten GKE-Clusterkonfiguration planen, einschließlich der bereitgestellten Arbeitslasten und deren Daten.

In dieser Anleitung konfigurieren Sie einen Sicherungsplan für Ihren GKE-Cluster, um täglich um 3:00 Uhr alle Arbeitslasten, einschließlich Secrets und Volumes, zu sichern. Um eine effiziente Speicherverwaltung zu gewährleisten, würden Sicherungen, die älter als drei Tage sind, automatisch gelöscht.

So konfigurieren Sie Sicherungspläne:

  1. Aktivieren Sie das Feature "Sicherung für GKE" für Ihren Cluster:

    gcloud container clusters update ${KUBERNETES_CLUSTER_PREFIX}-cluster \
    --project=${PROJECT_ID} \
    --region=${REGION} \
    --update-addons=BackupRestore=ENABLED
    
  2. Erstellen Sie einen Sicherungsplan mit einem täglichen Zeitplan für alle Namespaces im Cluster:

    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
    

    Der Befehl verwendet zur Laufzeit die relevanten Umgebungsvariablen.

    Das Format des Clusternamens bezieht sich auf Ihr Projekt und Ihre Region:

    projects/PROJECT_ID/locations/REGION/clusters/CLUSTER_NAME
    

    Geben Sie bei Aufforderung y. ein. Die Ausgabe sieht in etwa so aus:

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

    Dieser Vorgang kann einige Minuten dauern. Nach Abschluss der Ausführung sieht die Ausgabe in etwa so aus:

    Created backup plan [qdrant-cluster-backup].
    
  3. Der neu erstellte Sicherungsplan qdrant-cluster-backup wird in der Console von Backup for GKE aufgeführt.

    Zu „Sicherung für GKE“

Informationen zum Wiederherstellen der gespeicherten Sicherungskonfigurationen finden Sie unter Sicherung wiederherstellen.

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

Projekt löschen

Sie vermeiden weitere Kosten am einfachsten, wenn Sie das für die Anleitung erstellte Projekt löschen.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Wenn Sie das Projekt gelöscht haben, ist die Bereinigung abgeschlossen. Wenn Sie das Projekt nicht gelöscht haben, fahren Sie mit dem Löschen der einzelnen Ressourcen fort.

Einzelne Ressourcen löschen

  1. Umgebungsvariablen festlegen

    export PROJECT_ID=${PROJECT_ID}
    export KUBERNETES_CLUSTER_PREFIX=qdrant
    export REGION=us-central1
    
  2. Führen Sie den Befehl terraform destroy aus:

    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}
    

    Ersetzen Sie FOLDER je nach Typ des von Ihnen erstellten GKE-Clusters durch gke-autopilot oder gke-standard.

    Geben Sie bei Aufforderung yes ein.

  3. Alle nicht angehängten Laufwerke suchen:

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

    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
    
  5. GitHub-Repository löschen:

    rm -r ~/kubernetes-engine-samples/
    

Nächste Schritte