PostgreSQL-Vektordatenbank in GKE bereitstellen

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:

   export PROJECT_ID=PROJECT_ID
   export KUBERNETES_CLUSTER_PREFIX=postgres
   export REGION=us-central1
   

   • Ersetzen Sie PROJECT_ID durch Ihre Projekt-ID. Google Cloud

   In dieser Anleitung wird die Region us-central1 verwendet.

2. Klonen Sie das Beispielcode-Repository aus GitHub:

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

3. Rufen Sie das Verzeichnis postgres-pgvector auf:

   cd kubernetes-engine-samples/databases/postgres-pgvector
   

Clusterinfrastruktur erstellen

In diesem Abschnitt führen Sie ein Terraform-Skript aus, um einen privaten, hochverfügbaren regionalen GKE-Cluster zum Bereitstellen Ihrer PostgreSQL-Datenbank zu erstellen.

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

export GOOGLE_OAUTH_ACCESS_TOKEN=$(gcloud auth print-access-token)
terraform -chdir=../postgresql-cloudnativepg/terraform/gke-autopilot init
terraform -chdir=../postgresql-cloudnativepg/terraform/gke-autopilot apply \
-var project_id=${PROJECT_ID} \
-var region=${REGION} \
-var cluster_prefix=${KUBERNETES_CLUSTER_PREFIX}

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

export GOOGLE_OAUTH_ACCESS_TOKEN=$(gcloud auth print-access-token)
terraform -chdir=../postgresql-cloudnativepg/terraform/gke-standard init
terraform -chdir=../postgresql-cloudnativepg/terraform/gke-standard apply \
-var project_id=${PROJECT_ID} \
-var region=${REGION} \
-var cluster_prefix=${KUBERNETES_CLUSTER_PREFIX}

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

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} --project ${PROJECT_ID}

CloudNativePG-Operator bereitstellen

Stellen Sie die CloudNativePG mithilfe eines Helm-Diagramms in Ihrem Kubernetes-Cluster bereit:

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

2. Fügen Sie das Helm-Diagramm-Repository für den CloudNativePG-Operator hinzu:

   helm repo add cnpg https://cloudnative-pg.github.io/charts
   

3. Stellen Sie den CloudNativePG-Operator mit dem Helm-Befehlszeilentool bereit:

   helm upgrade --install cnpg \
       --namespace cnpg-system \
       --create-namespace \
       cnpg/cloudnative-pg
   

   Die Ausgabe sieht in etwa so aus:

   Release "cnpg" does not exist. Installing it now.
   NAME: cnpg
   LAST DEPLOYED: Fri Oct 13 13:52:36 2023
   NAMESPACE: cnpg-system
   STATUS: deployed
   REVISION: 1
   TEST SUITE: None
   ...
   

PostgreSQL-Vektordatenbank bereitstellen

In diesem Abschnitt stellen Sie die PostgreSQL-Vektordatenbank bereit.

1. Erstellen Sie einen Namespace pg-ns für die Datenbank:

   kubectl create ns pg-ns
   

2. Wenden Sie das Manifest an, um den PostgreSQL-Cluster bereitzustellen: Das Clustermanifest aktiviert die pgvector-Erweiterung.

   kubectl apply -n pg-ns -f manifests/01-basic-cluster/postgreSQL_cluster.yaml
   

   Das postgreSQL_cluster.yaml-Manifest beschreibt das Deployment:

   apiVersion: postgresql.cnpg.io/v1
   kind: Cluster
   metadata:
     name: gke-pg-cluster
   spec:
     description: "Standard GKE PostgreSQL cluster"
     imageName: ghcr.io/cloudnative-pg/postgresql:16.2
     enableSuperuserAccess: true
     instances: 3
     startDelay: 300
     primaryUpdateStrategy: unsupervised
     postgresql:
       pg_hba:
         - host all all 10.48.0.0/20 md5
     bootstrap:
       initdb:
         postInitTemplateSQL:
           - CREATE EXTENSION IF NOT EXISTS vector;
         database: app
     storage:
       storageClass: premium-rwo
       size: 2Gi
     resources:
       requests:
         memory: "1Gi"
         cpu: "1000m"
       limits:
         memory: "1Gi"
         cpu: "1000m"
     affinity:
       enablePodAntiAffinity: true
       tolerations:
       - key: cnpg.io/cluster
         effect: NoSchedule
         value: gke-pg-cluster
         operator: Equal
       additionalPodAffinity:
         preferredDuringSchedulingIgnoredDuringExecution:
         - weight: 1
           podAffinityTerm:
             labelSelector:
               matchExpressions:
               - key: app.component
                 operator: In
                 values:
                 - "pg-cluster"
             topologyKey: topology.kubernetes.io/zone
     monitoring:
       enablePodMonitor: true

3. Prüfen Sie den Clusterstatus:

   kubectl get cluster -n pg-ns --watch
   

   Warten Sie, bis die Ausgabe den Status Cluster in healthy state anzeigt, bevor Sie mit dem nächsten Schritt fortfahren.

Abfragen mit einem Vertex AI Colab Enterprise-Notebook ausführen

In diesem Abschnitt laden Sie Vektoren in eine PostgreSQL-Tabelle hoch und führen semantische Suchanfragen mit SQL-Syntax aus.

Sie stellen mit Colab Enterprise eine Verbindung zu Ihrer PostgreSQL-Datenbank her. Sie verwenden eine spezielle Runtime-Vorlage, um die Bereitstellung auf dem postgres-vpc vorzunehmen, damit das Notebook mit Ressourcen im GKE-Cluster kommunizieren kann.

Weitere Informationen zu Vertex AI Colab Enterprise finden Sie in der Colab Enterprise-Dokumentation.

Laufzeitvorlage erstellen.

So erstellen Sie eine Colab Enterprise-Laufzeitvorlage:

1. Rufen Sie in der Google Cloud Console die Colab Enterprise-Seite Laufzeitvorlagen auf und prüfen Sie, ob Ihr Projekt ausgewählt ist:

   Zu Laufzeitvorlagen

2. Klicken Sie auf add_box Neue Vorlage. Die Seite Neue Laufzeitvorlage erstellen wird angezeigt.

3. Im Abschnitt Laufzeitgrundlagen:

   • Geben Sie im Feld Anzeigename den Wert pgvector-connect ein.
   • Wählen Sie in der Drop-down-Liste Region us-central1 aus. Es ist dieselbe Region wie Ihr GKE-Cluster.

4. Im Abschnitt Compute konfigurieren:

   • Wählen Sie in der Drop-down-Liste Maschinentyp die Option e2-standard-2 aus.
   • Geben Sie im Feld Laufwerkgröße den Wert 30 ein.

5. Im Abschnitt Netzwerk und Sicherheit:

   • Wählen Sie in der Drop-down-Liste Netzwerk das Netzwerk aus, in dem sich Ihr GKE-Cluster befindet.
   • Wählen Sie in der Drop-down-Liste Subnetzwerk ein entsprechendes Subnetzwerk aus.
   • Entfernen Sie das Häkchen aus dem Kästchen Öffentlichen Internetzugriff aktivieren.

6. Klicken Sie auf Erstellen, um die Erstellung der Laufzeitvorlage abzuschließen. Ihre Laufzeitvorlage wird auf dem Tab Laufzeitvorlagen in der Liste angezeigt.

Laufzeit erstellen

So erstellen Sie eine Colab Enterprise-Laufzeit:

1. Klicken Sie in der Liste der Laufzeitvorlagen für die gerade erstellte Vorlage in der Spalte Aktionen auf more_vert und dann auf Laufzeit erstellen. Der Bereich Vertex AI-Laufzeit erstellen wird angezeigt.

2. Klicken Sie auf Erstellen, um eine Laufzeit auf Grundlage Ihrer Vorlage zu erstellen.

3. Warten Sie auf dem Tab Laufzeiten, bis der Status zu Fehlerfrei wechselt.

Notebook importieren

So importieren Sie das Notebook in Colab Enterprise:

1. Klicken Sie auf den Tab Meine Notebooks und dann auf Importieren. Der Bereich Notebooks importieren wird angezeigt.

2. Wählen Sie unter Importquelle die Option URL aus.

3. Geben Sie unter Notebook-URLs den folgenden Link ein:

   https://raw.githubusercontent.com/epam/kubernetes-engine-samples/internal_lb/databases/postgres-pgvector/manifests/02-notebook/vector-database.ipynb
   

4. Klicken Sie auf Importieren.

Mit der Laufzeit verbinden und Abfragen ausführen

So stellen Sie eine Verbindung zur Laufzeit her und führen Abfragen aus:

1. Klicken Sie im Notebook neben der Schaltfläche Verbinden auf arrow_drop_down Zusätzliche Verbindungsoptionen. Der Bereich Mit Vertex AI-Laufzeit verbinden wird angezeigt.

2. Wählen Sie Mit einer Laufzeit verbinden und dann Mit einer vorhandenen Laufzeit verbinden aus.

3. Wählen Sie die Laufzeit aus, die Sie gestartet haben, und klicken Sie auf Connect (Verbinden).

4. Klicken Sie zum Ausführen der Notebook-Zellen neben jeder Codezelle auf die Schaltfläche  Zelle ausführen.

Das Notebook enthält sowohl Codezellen als auch Text, der die einzelnen Codeblöcke beschreibt. Wenn Sie eine Codezelle ausführen, werden die darin enthaltenen Befehle ausgeführt und eine Ausgabe wird angezeigt. Sie können die Zellen der Reihe nach oder nach Bedarf einzeln ausführen.