1. Einführung
In diesem Codelab erfahren Sie, wie Sie die AlloyDB-KI verwenden, indem Sie die Vektorsuche mit Vertex AI-Einbettungen kombinieren.
Voraussetzungen
- Grundlegende Kenntnisse der Google Cloud Console
- Grundlegende Kenntnisse der Befehlszeile und der Google-Shell
Aufgaben in diesem Lab
- AlloyDB-Cluster und primäre Instanz bereitstellen
- Verbindung von einer Google Compute Engine-VM zu AlloyDB herstellen
- Datenbank erstellen und AlloyDB AI aktivieren
- Daten in die Datenbank laden
- Vertex AI-Embedding-Modell in AlloyDB verwenden
- Ergebnis mit dem generativen Vertex AI-Modell anreichern
- Leistung mithilfe eines Vektorindexes verbessern
Voraussetzungen
- Ein Google Cloud-Konto und ein Google Cloud-Projekt
- Einen Webbrowser wie Chrome
2. Einrichtung und Anforderungen
Umgebung für das selbstbestimmte Lernen einrichten
- Melden Sie sich in der Google Cloud Console an und erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes. Wenn Sie noch kein Gmail- oder Google Workspace-Konto haben, müssen Sie eines erstellen.
- Der Projektname ist der Anzeigename für die Projektteilnehmer. Es ist ein Zeichenstring, der von Google APIs nicht verwendet wird. Sie können ihn jederzeit aktualisieren.
- Die Projekt-ID ist für alle Google Cloud-Projekte eindeutig und unveränderlich. Sie kann nach dem Festlegen nicht mehr geändert werden. In der Cloud Console wird automatisch ein eindeutiger String generiert. In der Regel spielt es keine Rolle, wie er lautet. In den meisten Codelabs müssen Sie auf Ihre Projekt-ID verweisen (normalerweise als
PROJECT_IDgekennzeichnet). Wenn Ihnen die generierte ID nicht gefällt, können Sie eine andere zufällige generieren. Alternativ können Sie einen eigenen verwenden und nachsehen, ob er verfügbar ist. Sie kann nach diesem Schritt nicht mehr geändert werden und bleibt für die Dauer des Projekts bestehen. - Zur Information gibt es noch einen dritten Wert, die Projektnummer, die von manchen APIs verwendet wird. Weitere Informationen zu diesen drei Werten finden Sie in der Dokumentation.
- Als Nächstes müssen Sie die Abrechnung in der Cloud Console aktivieren, um Cloud-Ressourcen/-APIs verwenden zu können. Dieses Codelab ist kostengünstig. Wenn Sie die Ressourcen herunterfahren möchten, um Kosten nach Abschluss dieser Anleitung zu vermeiden, können Sie die von Ihnen erstellten Ressourcen oder das Projekt löschen. Neue Google Cloud-Nutzer haben Anspruch auf das kostenlose Testprogramm mit 300$Guthaben.
Cloud Shell starten
Sie können Google Cloud zwar per Fernzugriff von Ihrem Laptop aus nutzen, in diesem Codelab verwenden Sie jedoch Google Cloud Shell, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.
Klicken Sie in der Google Cloud Console rechts oben in der Symbolleiste auf das Cloud Shell-Symbol:
Die Bereitstellung und Verbindung mit der Umgebung dauert nur einen Moment. Wenn der Vorgang abgeschlossen ist, sollte in etwa Folgendes angezeigt werden:
Diese virtuelle Maschine verfügt über sämtliche Entwicklertools, die Sie benötigen. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft auf Google Cloud, was die Netzwerkleistung und Authentifizierung erheblich verbessert. Alle Arbeiten in diesem Codelab können in einem Browser erledigt werden. Sie müssen nichts installieren.
3. Vorbereitung
API aktivieren
Ausgabe:
Prüfen Sie in Cloud Shell, ob Ihre Projekt-ID eingerichtet ist:
gcloud config set project [YOUR-PROJECT-ID]
Legen Sie die Umgebungsvariable PROJECT_ID fest:
PROJECT_ID=$(gcloud config get-value project)
Aktivieren Sie alle erforderlichen Dienste:
gcloud services enable alloydb.googleapis.com \
compute.googleapis.com \
cloudresourcemanager.googleapis.com \
servicenetworking.googleapis.com \
aiplatform.googleapis.com
Erwartete Ausgabe
student@cloudshell:~ (test-project-001-402417)$ gcloud config set project test-project-001-402417
Updated property [core/project].
student@cloudshell:~ (test-project-001-402417)$ PROJECT_ID=$(gcloud config get-value project)
Your active configuration is: [cloudshell-14650]
student@cloudshell:~ (test-project-001-402417)$
student@cloudshell:~ (test-project-001-402417)$ gcloud services enable alloydb.googleapis.com \
compute.googleapis.com \
cloudresourcemanager.googleapis.com \
servicenetworking.googleapis.com \
aiplatform.googleapis.com
Operation "operations/acat.p2-4470404856-1f44ebd8-894e-4356-bea7-b84165a57442" finished successfully.
Konfigurieren Sie Ihre Standardregion so, dass die Vertex AI-Embedding-Modelle verwendet werden. Weitere Informationen zu verfügbaren Standorten für Vertex AI In diesem Beispiel verwenden wir die Region „us-central1“.
gcloud config set compute/region us-central1
4. AlloyDB bereitstellen
Bevor wir einen AlloyDB-Cluster erstellen, benötigen wir einen verfügbaren privaten IP-Bereich in unserer VPC, der von der zukünftigen AlloyDB-Instanz verwendet werden soll. Wenn wir sie nicht haben, müssen wir sie erstellen und für die Verwendung durch interne Google-Dienste zuweisen. Danach können wir den Cluster und die Instanz erstellen.
Privaten IP-Bereich erstellen
Wir müssen die Konfiguration des privaten Dienstzugriffs in unserer VPC für AlloyDB konfigurieren. Hier wird angenommen, dass es den „Standard“-Wert VPC-Netzwerk im Projekt und wird für alle Aktionen verwendet.
Erstellen Sie den privaten IP-Bereich:
gcloud compute addresses create psa-range \
--global \
--purpose=VPC_PEERING \
--prefix-length=24 \
--description="VPC private service access" \
--network=default
Erstellen Sie eine private Verbindung mit dem zugewiesenen IP-Bereich:
gcloud services vpc-peerings connect \
--service=servicenetworking.googleapis.com \
--ranges=psa-range \
--network=default
Erwartete Konsolenausgabe:
student@cloudshell:~ (test-project-402417)$ gcloud compute addresses create psa-range \
--global \
--purpose=VPC_PEERING \
--prefix-length=24 \
--description="VPC private service access" \
--network=default
Created [https://www.googleapis.com/compute/v1/projects/test-project-402417/global/addresses/psa-range].
student@cloudshell:~ (test-project-402417)$ gcloud services vpc-peerings connect \
--service=servicenetworking.googleapis.com \
--ranges=psa-range \
--network=default
Operation "operations/pssn.p24-4470404856-595e209f-19b7-4669-8a71-cbd45de8ba66" finished successfully.
student@cloudshell:~ (test-project-402417)$
AlloyDB-Cluster erstellen
Erstellen Sie einen AlloyDB-Cluster in der Region „us-central1“.
Legen Sie ein Passwort für den Nutzer „postgres“ fest. Sie können Ihr eigenes Passwort festlegen oder es mithilfe einer Zufallsfunktion generieren
export PGPASSWORD=`openssl rand -hex 12`
Erwartete Console-Ausgabe:
student@cloudshell:~ (test-project-402417)$ export PGPASSWORD=`openssl rand -hex 12`
Notieren Sie sich das PostgreSQL-Passwort für die zukünftige Verwendung:
echo $PGPASSWORD
Erwartete Konsolenausgabe:
student@cloudshell:~ (test-project-402417)$ echo $PGPASSWORD bbefbfde7601985b0dee5723
Definieren Sie die Region und den AlloyDB-Clusternamen. Wir verwenden die Region „us-central1“ und „alloydb-aip-01“ als Clusternamen:
export REGION=us-central1
export ADBCLUSTER=alloydb-aip-01
Führen Sie den Befehl zum Erstellen des Clusters aus:
gcloud alloydb clusters create $ADBCLUSTER \
--password=$PGPASSWORD \
--network=default \
--region=$REGION
Erwartete Konsolenausgabe:
export REGION=us-central1
export ADBCLUSTER=alloydb-aip-01
gcloud alloydb clusters create $ADBCLUSTER \
--password=$PGPASSWORD \
--network=default \
--region=$REGION
Operation ID: operation-1697655441138-6080235852277-9e7f04f5-2012fce4
Creating cluster...done.
Primäre AlloyDB-Instanz erstellen
Erstellen Sie in derselben Cloud Shell-Sitzung eine primäre AlloyDB-Instanz für unseren Cluster. Wenn die Verbindung getrennt ist, müssen Sie die Umgebungsvariablen für die Region und den Clusternamen noch einmal definieren.
gcloud alloydb instances create $ADBCLUSTER-pr \
--instance-type=PRIMARY \
--cpu-count=2 \
--region=$REGION \
--cluster=$ADBCLUSTER
Erwartete Console-Ausgabe:
student@cloudshell:~ (test-project-402417)$ gcloud alloydb instances create $ADBCLUSTER-pr \
--instance-type=PRIMARY \
--cpu-count=2 \
--region=$REGION \
--availability-type ZONAL \
--cluster=$ADBCLUSTER
Operation ID: operation-1697659203545-6080315c6e8ee-391805db-25852721
Creating instance...done.
5. Mit AlloyDB verbinden
AlloyDB wird über eine ausschließlich private Verbindung bereitgestellt. Daher benötigen wir eine VM mit installiertem PostgreSQL-Client, um mit der Datenbank zu arbeiten.
GCE-VM bereitstellen
Erstellen Sie eine GCE-VM in derselben Region und im selben VPC wie der AlloyDB-Cluster.
Führen Sie in Cloud Shell Folgendes aus:
export ZONE=us-central1-a
gcloud compute instances create instance-1 \
--zone=$ZONE \
--create-disk=auto-delete=yes,boot=yes,image=projects/debian-cloud/global/images/$(gcloud compute images list --filter="family=debian-12 AND family!=debian-12-arm64" --format="value(name)") \
--scopes=https://www.googleapis.com/auth/cloud-platform
Erwartete Konsolenausgabe:
student@cloudshell:~ (test-project-402417)$ export ZONE=us-central1-a
student@cloudshell:~ (test-project-402417)$ export ZONE=us-central1-a
gcloud compute instances create instance-1 \
--zone=$ZONE \
--create-disk=auto-delete=yes,boot=yes,image=projects/debian-cloud/global/images/$(gcloud compute images list --filter="family=debian-12 AND family!=debian-12-arm64" --format="value(name)") \
--scopes=https://www.googleapis.com/auth/cloud-platform
Created [https://www.googleapis.com/compute/v1/projects/test-project-402417/zones/us-central1-a/instances/instance-1].
NAME: instance-1
ZONE: us-central1-a
MACHINE_TYPE: n1-standard-1
PREEMPTIBLE:
INTERNAL_IP: 10.128.0.2
EXTERNAL_IP: 34.71.192.233
STATUS: RUNNING
Postgres-Client installieren
PostgreSQL-Clientsoftware auf der bereitgestellten VM installieren
Stellen Sie eine Verbindung zur VM her.
gcloud compute ssh instance-1 --zone=us-central1-a
Erwartete Console-Ausgabe:
student@cloudshell:~ (test-project-402417)$ gcloud compute ssh instance-1 --zone=us-central1-a Updating project ssh metadata...working..Updated [https://www.googleapis.com/compute/v1/projects/test-project-402417]. Updating project ssh metadata...done. Waiting for SSH key to propagate. Warning: Permanently added 'compute.5110295539541121102' (ECDSA) to the list of known hosts. Linux instance-1.us-central1-a.c.gleb-test-short-001-418811.internal 6.1.0-18-cloud-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.76-1 (2024-02-01) x86_64 The programs included with the Debian GNU/Linux system are free software; the exact distribution terms for each program are described in the individual files in /usr/share/doc/*/copyright. Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent permitted by applicable law. student@instance-1:~$
Installieren Sie die Software, die den Befehl ausführt, auf der VM:
sudo apt-get update
sudo apt-get install --yes postgresql-client
Erwartete Konsolenausgabe:
student@instance-1:~$ sudo apt-get update sudo apt-get install --yes postgresql-client Get:1 https://packages.cloud.google.com/apt google-compute-engine-bullseye-stable InRelease [5146 B] Get:2 https://packages.cloud.google.com/apt cloud-sdk-bullseye InRelease [6406 B] Hit:3 https://deb.debian.org/debian bullseye InRelease Get:4 https://deb.debian.org/debian-security bullseye-security InRelease [48.4 kB] Get:5 https://packages.cloud.google.com/apt google-compute-engine-bullseye-stable/main amd64 Packages [1930 B] Get:6 https://deb.debian.org/debian bullseye-updates InRelease [44.1 kB] Get:7 https://deb.debian.org/debian bullseye-backports InRelease [49.0 kB] ...redacted... update-alternatives: using /usr/share/postgresql/13/man/man1/psql.1.gz to provide /usr/share/man/man1/psql.1.gz (psql.1.gz) in auto mode Setting up postgresql-client (13+225) ... Processing triggers for man-db (2.9.4-2) ... Processing triggers for libc-bin (2.31-13+deb11u7) ...
Verbindung zur Instanz herstellen
Stellen Sie über psql eine Verbindung von der VM zur primären Instanz her.
Öffnen Sie im selben Cloud Shell-Tab die geöffnete SSH-Sitzung für Ihre VM „instance-1“.
Verwenden Sie den angegebenen AlloyDB-Passwortwert (PGPASSWORD) und die AlloyDB-Cluster-ID, um eine Verbindung von der GCE-VM zu AlloyDB herzustellen:
export PGPASSWORD=<Noted password>
export PROJECT_ID=$(gcloud config get-value project)
export REGION=us-central1
export ADBCLUSTER=alloydb-aip-01
export INSTANCE_IP=$(gcloud alloydb instances describe $ADBCLUSTER-pr --cluster=$ADBCLUSTER --region=$REGION --format="value(ipAddress)")
psql "host=$INSTANCE_IP user=postgres sslmode=require"
Erwartete Konsolenausgabe:
student@instance-1:~$ export PGPASSWORD=CQhOi5OygD4ps6ty student@instance-1:~$ ADBCLUSTER=alloydb-aip-01 student@instance-1:~$ REGION=us-central1 student@instance-1:~$ INSTANCE_IP=$(gcloud alloydb instances describe $ADBCLUSTER-pr --cluster=$ADBCLUSTER --region=$REGION --format="value(ipAddress)") gleb@instance-1:~$ psql "host=$INSTANCE_IP user=postgres sslmode=require" psql (15.6 (Debian 15.6-0+deb12u1), server 15.5) SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, compression: off) Type "help" for help. postgres=>
Schließen Sie die psql-Sitzung:
exit
6. Datenbank vorbereiten
Wir müssen eine Datenbank erstellen, die Vertex AI-Integration aktivieren, Datenbankobjekte erstellen und die Daten importieren.
Erforderliche Berechtigungen für AlloyDB gewähren
Fügen Sie dem AlloyDB-Dienst-Agent Vertex AI-Berechtigungen hinzu.
Öffnen Sie einen weiteren Cloud Shell-Tab mit dem Zeichen „+“ ganz oben.
Führen Sie auf dem neuen Cloud Shell-Tab Folgendes aus:
PROJECT_ID=$(gcloud config get-value project)
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:service-$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")@gcp-sa-alloydb.iam.gserviceaccount.com" \
--role="roles/aiplatform.user"
Erwartete Console-Ausgabe:
student@cloudshell:~ (test-project-001-402417)$ PROJECT_ID=$(gcloud config get-value project) Your active configuration is: [cloudshell-11039] student@cloudshell:~ (test-project-001-402417)$ gcloud projects add-iam-policy-binding $PROJECT_ID \ --member="serviceAccount:service-$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")@gcp-sa-alloydb.iam.gserviceaccount.com" \ --role="roles/aiplatform.user" Updated IAM policy for project [test-project-001-402417]. bindings: - members: - serviceAccount:service-4470404856@gcp-sa-alloydb.iam.gserviceaccount.com role: roles/aiplatform.user - members: ... etag: BwYIEbe_Z3U= version: 1
Schließen Sie den Tab mit dem Ausführungsbefehl „exit“ auf dem Tab:
exit
Datenbank erstellen
Datenbank erstellen – Kurzanleitung
Führen Sie in der GCE-VM-Sitzung Folgendes aus:
So erstellen Sie eine Datenbank:
psql "host=$INSTANCE_IP user=postgres" -c "CREATE DATABASE quickstart_db"
Erwartete Console-Ausgabe:
student@instance-1:~$ psql "host=$INSTANCE_IP user=postgres" -c "CREATE DATABASE quickstart_db" CREATE DATABASE student@instance-1:~$
Vertex AI Integration aktivieren
Aktivieren Sie die Vertex AI-Integration und die pgvector-Erweiterungen in der Datenbank.
Führen Sie auf der GCE-VM Folgendes aus:
psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "CREATE EXTENSION IF NOT EXISTS google_ml_integration CASCADE"
psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "CREATE EXTENSION IF NOT EXISTS vector"
Erwartete Console-Ausgabe:
student@instance-1:~$ psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "CREATE EXTENSION IF NOT EXISTS google_ml_integration CASCADE" psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "CREATE EXTENSION IF NOT EXISTS vector" CREATE EXTENSION CREATE EXTENSION student@instance-1:~$
Daten importieren
Laden Sie die vorbereiteten Daten herunter und importieren Sie sie in die neue Datenbank.
Führen Sie auf der GCE-VM Folgendes aus:
gsutil cat gs://cloud-training/gcc/gcc-tech-004/cymbal_demo_schema.sql |psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db"
gsutil cat gs://cloud-training/gcc/gcc-tech-004/cymbal_products.csv |psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "\copy cymbal_products from stdin csv header"
gsutil cat gs://cloud-training/gcc/gcc-tech-004/cymbal_inventory.csv |psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "\copy cymbal_inventory from stdin csv header"
gsutil cat gs://cloud-training/gcc/gcc-tech-004/cymbal_stores.csv |psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "\copy cymbal_stores from stdin csv header"
Erwartete Konsolenausgabe:
student@instance-1:~$ gsutil cat gs://cloud-training/gcc/gcc-tech-004/cymbal_demo_schema.sql |psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" SET SET SET SET SET set_config ------------ (1 row) SET SET SET SET SET SET CREATE TABLE ALTER TABLE CREATE TABLE ALTER TABLE CREATE TABLE ALTER TABLE CREATE TABLE ALTER TABLE CREATE SEQUENCE ALTER TABLE ALTER SEQUENCE ALTER TABLE ALTER TABLE ALTER TABLE student@instance-1:~$ gsutil cat gs://cloud-training/gcc/gcc-tech-004/cymbal_products.csv |psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "\copy cymbal_products from stdin csv header" COPY 941 student@instance-1:~$ gsutil cat gs://cloud-training/gcc/gcc-tech-004/cymbal_inventory.csv |psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "\copy cymbal_inventory from stdin csv header" COPY 263861 student@instance-1:~$ gsutil cat gs://cloud-training/gcc/gcc-tech-004/cymbal_stores.csv |psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "\copy cymbal_stores from stdin csv header" COPY 4654 student@instance-1:~$
7. Einbettungen berechnen
Nach dem Import der Daten haben wir unsere Produktdaten in die Tabelle „cymbal_products“, das Inventar mit der Anzahl der verfügbaren Produkte in jedem Geschäft in der Tabelle „cymbal_inventory“ und die Liste der Geschäfte in der Tabelle „cymbal_stores“ erhalten. Wir müssen die Vektordaten anhand der Beschreibungen für unsere Produkte berechnen und verwenden dafür die Funktionseinbettung. Mit der Funktion berechnen wir mithilfe der Integration von Vertex AI Vektordaten anhand unserer Produktbeschreibungen und fügen sie der Tabelle hinzu. Weitere Informationen zur verwendeten Technologie finden Sie in der Dokumentation.
Einbettungsspalte erstellen
Stellen Sie über psql eine Verbindung zur Datenbank her und erstellen Sie mithilfe der Einbettungsfunktion in der Tabelle „cymbal_products“ eine virtuelle Spalte mit den Vektordaten. Die Einbettungsfunktion gibt Vektordaten aus Vertex AI anhand der Daten aus der Spalte „product_description“ zurück.
psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db"
Führen Sie in der psql-Sitzung nach der Verbindung zur Datenbank Folgendes aus:
ALTER TABLE cymbal_products ADD COLUMN embedding vector(768) GENERATED ALWAYS AS (embedding('text-embedding-004',product_description)) STORED;
Mit dem Befehl wird die virtuelle Spalte erstellt und mit Vektordaten gefüllt.
Erwartete Console-Ausgabe:
student@instance-1:~$ psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db"
psql (13.11 (Debian 13.11-0+deb11u1), server 14.7)
WARNING: psql major version 13, server major version 14.
Some psql features might not work.
SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, bits: 256, compression: off)
Type "help" for help.
quickstart_db=> ALTER TABLE cymbal_products ADD COLUMN embedding vector(768) GENERATED ALWAYS AS (embedding('text-embedding-004',product_description)) STORED;
ALTER TABLE
quickstart_db=>
8. Ähnlichkeitssuche ausführen
Wir können nun unsere Suche mit einer Ähnlichkeitssuche durchführen, die auf Vektorwerten basiert, die für die Beschreibungen und dem Vektorwert, den wir für unsere Anfrage erhalten, berechnet wurden.
Die SQL-Abfrage kann über dieselbe psql-Befehlszeile oder alternativ über AlloyDB Studio ausgeführt werden. Jede mehrzeilige und komplexe Ausgabe sieht in AlloyDB Studio möglicherweise besser aus.
Mit AlloyDB Studio verbinden
In den folgenden Kapiteln können alle SQL-Befehle, die eine Verbindung zur Datenbank erfordern, alternativ in AlloyDB Studio ausgeführt werden. Um den Befehl auszuführen, müssen Sie die Webkonsole für Ihren AlloyDB-Cluster öffnen. Klicken Sie dazu auf die primäre Instanz.
Klicken Sie dann links auf „AlloyDB Studio“:
Wählen Sie die Datenbank „quickstart_db“ und den Nutzer „postgres“ aus und geben Sie das Passwort ein, das Sie beim Erstellen des Clusters notiert haben. Klicken Sie dann auf die Schaltfläche „Authentifizieren“.
Die AlloyDB Studio-Benutzeroberfläche wird geöffnet. Klicken Sie auf „Editor 1“, um die Befehle in der Datenbank auszuführen. auf der rechten Seite.
Eine Schnittstelle wird geöffnet, auf der Sie SQL-Befehle ausführen können
Wenn Sie lieber die psql-Befehlszeile verwenden, folgen Sie der alternativen Route und stellen Sie von Ihrer VM-SSH-Sitzung aus eine Verbindung zur Datenbank her, wie in den vorherigen Kapiteln beschrieben.
Ähnlichkeitssuche über psql ausführen
Wenn die Verbindung zu Ihrer Datenbank getrennt wurde, stellen Sie über psql oder AlloyDB Studio wieder eine Verbindung her.
Stellen Sie eine Verbindung zur Datenbank her:
psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db"
Führen Sie eine Abfrage aus, um eine Liste der verfügbaren Produkte abzurufen, die am ehesten der Anfrage eines Kunden entsprechen. Die Anfrage, die wir an Vertex AI senden, um den Vektorwert zu erhalten, lautet: „Welche Obstbäume gedeihen hier gut?“
Mit der folgenden Abfrage können Sie die ersten zehn Elemente auswählen, die für unsere Anfrage am besten geeignet sind:
SELECT
cp.product_name,
left(cp.product_description,80) as description,
cp.sale_price,
cs.zip_code,
(cp.embedding <=> embedding('text-embedding-004','What kind of fruit trees grow well here?')::vector) as distance
FROM
cymbal_products cp
JOIN cymbal_inventory ci on
ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
cs.store_id=ci.store_id
AND ci.inventory>0
AND cs.store_id = 1583
ORDER BY
distance ASC
LIMIT 10;
Und hier ist die erwartete Ausgabe:
quickstart_db=> SELECT
cp.product_name,
left(cp.product_description,80) as description,
cp.sale_price,
cs.zip_code,
(cp.embedding <=> embedding('text-embedding-004','What kind of fruit trees grow well here?')::vector) as distance
FROM
cymbal_products cp
JOIN cymbal_inventory ci on
ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
cs.store_id=ci.store_id
AND ci.inventory>0
AND cs.store_id = 1583
ORDER BY
distance ASC
LIMIT 10;
product_name | description | sale_price | zip_code | distance
-------------------------+----------------------------------------------------------------------------------+------------+----------+---------------------
Cherry Tree | This is a beautiful cherry tree that will produce delicious cherries. It is an d | 75.00 | 93230 | 0.43922018972266397
Meyer Lemon Tree | Meyer Lemon trees are California's favorite lemon tree! Grow your own lemons by | 34 | 93230 | 0.4685112926118228
Toyon | This is a beautiful toyon tree that can grow to be over 20 feet tall. It is an e | 10.00 | 93230 | 0.4835677149651668
California Lilac | This is a beautiful lilac tree that can grow to be over 10 feet tall. It is an d | 5.00 | 93230 | 0.4947204525907498
California Peppertree | This is a beautiful peppertree that can grow to be over 30 feet tall. It is an e | 25.00 | 93230 | 0.5054166905547247
California Black Walnut | This is a beautiful walnut tree that can grow to be over 80 feet tall. It is a d | 100.00 | 93230 | 0.5084219510932597
California Sycamore | This is a beautiful sycamore tree that can grow to be over 100 feet tall. It is | 300.00 | 93230 | 0.5140519790508755
Coast Live Oak | This is a beautiful oak tree that can grow to be over 100 feet tall. It is an ev | 500.00 | 93230 | 0.5143126438081371
Fremont Cottonwood | This is a beautiful cottonwood tree that can grow to be over 100 feet tall. It i | 200.00 | 93230 | 0.5174774727252058
Madrone | This is a beautiful madrona tree that can grow to be over 80 feet tall. It is an | 50.00 | 93230 | 0.5227400803389093
9. Antwort verbessern
Sie können die Antwort auf eine Clientanwendung mithilfe des Abfrageergebnisses verbessern und eine aussagekräftige Ausgabe mit den bereitgestellten Abfrageergebnissen als Teil des Prompts für das Vertex AI-generative Foundation Language Model erstellen.
Dazu planen wir, mit unseren Ergebnissen aus der Vektorsuche eine JSON-Datei zu generieren. Anschließend verwenden wir diese generierte JSON-Datei als Prompt für ein Text-LLM-Modell in Vertex AI, um eine aussagekräftige Ausgabe zu erstellen. Im ersten Schritt generieren wir die JSON-Datei, testen sie dann in Vertex AI Studio und fügen sie im letzten Schritt in eine SQL-Anweisung ein, die in einer Anwendung verwendet werden kann.
Ausgabe im JSON-Format generieren
Ändern Sie die Abfrage so, dass die Ausgabe im JSON-Format generiert wird und nur eine Zeile zurückgegeben wird, die an Vertex AI übergeben wird.
Hier ein Beispiel für die Abfrage:
WITH trees as (
SELECT
cp.product_name,
left(cp.product_description,80) as description,
cp.sale_price,
cs.zip_code,
cp.uniq_id as product_id
FROM
cymbal_products cp
JOIN cymbal_inventory ci on
ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
cs.store_id=ci.store_id
AND ci.inventory>0
AND cs.store_id = 1583
ORDER BY
(cp.embedding <=> embedding('text-embedding-004','What kind of fruit trees grow well here?')::vector) ASC
LIMIT 1)
SELECT json_agg(trees) FROM trees;
Und hier ist die erwartete JSON-Ausgabe:
[{"product_name":"Cherry Tree","description":"This is a beautiful cherry tree that will produce delicious cherries. It is an d","sale_price":75.00,"zip_code":93230,"product_id":"d536e9e823296a2eba198e52dd23e712"}]
Prompt in Vertex AI Studio ausführen
Wir können die generierte JSON-Datei als Teil des Prompts für das generative KI-Textmodell in Vertex AI Studio verwenden.
Öffnen Sie Vertex AI Studio in der Cloud Console.
Möglicherweise werden Sie aufgefordert, zusätzliche APIs zu aktivieren, Sie können die Anfrage jedoch ignorieren. Für unser Lab benötigen wir keine weiteren APIs.
Hier ist unser Prompt:
Sie sind ein freundlicher Berater, der Kunden bei der Auswahl eines Produkts entsprechend ihren Anforderungen hilft.
Basierend auf der Kundenanfrage haben wir eine Liste mit Produkten geladen, die eng mit der Suchanfrage zusammenhängen.
Die Liste im JSON-Format mit einer Liste von Werten wie {"product_name":"name","description":"some description","sale_price":10,"zip_code": 10234, "produt_id": "02056727942aeb714dc9a2313654e1b0"}
Hier ist die Liste der Produkte:
[place for our JSON]
Der Kunde fragt: „Welcher Baum gedeiht hier am besten?“
Sie sollten Informationen zum Produkt, zum Preis und einige ergänzende Informationen als Prompt geben.
Und hier ist das Ergebnis, wenn wir den Prompt mit unseren JSON-Werten und dem gemini-1.5-Flash-Modell ausführen:
Die Antwort, die wir in diesem Beispiel vom Modell erhalten haben, folgt. Hinweis: Ihre Antwort kann aufgrund von Modell- und Parameteränderungen im Laufe der Zeit abweichen:
„Wie ich sehe, suchen Sie nach einem Baum, der in Ihrer Gegend gedeiht. Nach deiner Postleitzahl 93230 scheint der Kirschbaum eine gute Option zu sein.
Er wird als schöner Baum beschrieben, der köstliche Kirschen trägt. Es ist derzeit im Angebot für 75,00 €.
Ich habe zwar keine spezifischen Informationen zur Wachstumsrate in Ihrer Region, aber ich kann Ihnen sagen, dass Kirschbäume im Allgemeinen gut durchlässigen Boden und volle Sonne bevorzugen.
Um optimale Ergebnisse zu erzielen, empfehle ich dir, dich an eine Gärtnerei oder einen Gartenexperten vor Ort zu wenden, der dich besser auf deinen spezifischen Standort und deine Bodenbedingungen beraten kann. Außerdem können sie Ihnen helfen, die für Ihre Bedürfnisse am besten geeignete Sorte auszuwählen, und Ihnen Tipps zur Pflanzung und Pflege geben.“
Prompt in PSQL ausführen
Durch die Einbindung von AlloyDB AI in Vertex AI können wir die gleiche Antwort von einem generativen Modell mit SQL direkt in der Datenbank erhalten. Um das gemini-1.5-Flash-Modell verwenden zu können, müssen wir es jedoch zuerst registrieren.
Führen Sie ein Upgrade der Erweiterung auf Version 1.4.1 durch, falls die aktuelle Version niedriger ist. Stellen Sie über psql eine Verbindung zur Datenbank „quickstart_db“ her (oder verwenden Sie AlloyDB Studio) und führen Sie den folgenden Befehl aus:
SELECT extversion from pg_extension where extname='google_ml_integration';
Wenn der zurückgegebene Wert unter 1.4.1 liegt, führe Folgendes aus:
ALTER EXTENSION google_ml_integration UPDATE TO '1.4.1';
Dann müssen wir das Datenbank-Flag „google_ml_integration.enable_model_support“ auf „on“ setzen. Dazu können Sie die AlloyDB-Webkonsole oder den folgenden gcloud-Befehl verwenden.
PROJECT_ID=$(gcloud config get-value project)
REGION=us-central1
ADBCLUSTER=alloydb-aip-01
gcloud beta alloydb instances update $ADBCLUSTER-pr \
--database-flags google_ml_integration.enable_model_support=on \
--region=$REGION \
--cluster=$ADBCLUSTER \
--project=$PROJECT_ID \
--update-mode=FORCE_APPLY
Die Ausführung des Befehls im Hintergrund dauert etwa 3 bis 5 Minuten. Anschließend können Sie das neue Flag in der psql-Sitzung prüfen oder AlloyDB Studio verwenden, um eine Verbindung zur Datenbank „quickstart_db“ herzustellen.
show google_ml_integration.enable_model_support;
Die erwartete Ausgabe der psql-Sitzung ist „on“:
postgres=> show google_ml_integration.enable_model_support; google_ml_integration.enable_model_support -------------------------------------------- on (1 row)
Dann müssen wir zwei Modelle registrieren. Das erste Modell ist das bereits verwendete Modell text-embedding-004. Es muss registriert werden, da wir die Funktionen zur Modellregistrierung aktiviert haben.
Um das Modell zu registrieren, führen Sie den folgenden Code in psql oder AlloyDB Studio aus:
CALL
google_ml.create_model(
model_id => 'text-embedding-004',
model_provider => 'google',
model_qualified_name => 'text-embedding-004',
model_type => 'text_embedding',
model_auth_type => 'alloydb_service_agent_iam',
model_in_transform_fn => 'google_ml.vertexai_text_embedding_input_transform',
model_out_transform_fn => 'google_ml.vertexai_text_embedding_output_transform');
Das nächste Modell, das wir registrieren müssen, ist gemini-1.5-flash-002, mit dem die nutzerfreundliche Ausgabe generiert wird.
CALL
google_ml.create_model(
model_id => 'gemini-1.5-flash-002',
model_request_url => 'https://$REGION-aiplatform.googleapis.com/v1/projects/$PROJECT_ID/locations/$REGION/publishers/google/models/gemini-1.5-flash-002:streamGenerateContent',
model_provider => 'google',
model_auth_type => 'alloydb_service_agent_iam');
Sie können die Liste der registrierten Modelle jederzeit überprüfen, indem Sie Informationen aus der Ansicht google_ml.model_info_view auswählen.
select model_id,model_type from google_ml.model_info_view;
Hier eine Beispielausgabe
quickstart_db=> select model_id,model_type from google_ml.model_info_view;
model_id | model_type
-------------------------+----------------
textembedding-gecko | text_embedding
textembedding-gecko@001 | text_embedding
text-embedding-004 | text_embedding
gemini-1.5-flash-001 | generic
(4 rows)
Jetzt können wir die in einer Unterabfrage generierten JSON-Datei verwenden, um sie als Teil des Prompts für das generative KI-Textmodell mit SQL bereitzustellen.
Führen Sie die Abfrage in der psql- oder AlloyDB Studio-Sitzung für die Datenbank aus.
WITH trees AS (
SELECT
cp.product_name,
cp.product_description AS description,
cp.sale_price,
cs.zip_code,
cp.uniq_id AS product_id
FROM
cymbal_products cp
JOIN cymbal_inventory ci ON
ci.uniq_id = cp.uniq_id
JOIN cymbal_stores cs ON
cs.store_id = ci.store_id
AND ci.inventory>0
AND cs.store_id = 1583
ORDER BY
(cp.embedding <=> embedding('text-embedding-004',
'What kind of fruit trees grow well here?')::vector) ASC
LIMIT 1),
prompt AS (
SELECT
'You are a friendly advisor helping to find a product based on the customer''s needs.
Based on the client request we have loaded a list of products closely related to search.
The list in JSON format with list of values like {"product_name":"name","product_description":"some description","sale_price":10}
Here is the list of products:' || json_agg(trees) || 'The customer asked "What kind of fruit trees grow well here?"
You should give information about the product, price and some supplemental information' AS prompt_text
FROM
trees),
response AS (
SELECT
json_array_elements(google_ml.predict_row( model_id =>'gemini-1.5-flash-002',
request_body => json_build_object('contents',
json_build_object('role',
'user',
'parts',
json_build_object('text',
prompt_text)))))->'candidates'->0->'content'->'parts'->0->'text' AS resp
FROM
prompt)
SELECT
string_agg(resp::text,
' ')
FROM
response;
Und hier ist die erwartete Ausgabe. Die Ausgabe kann je nach Modellversion und Parametern variieren:
"That" "'s a great question! Based on your location (assuming you're" " in zip code 93230), I have a suggestion for a" " fruit tree that should thrive.\n\nWe have the **Cherry Tree** available.\n\n**Product Name:** Cherry Tree\n\n**Description:** This is a beautiful cherry" " tree that will produce delicious cherries. It's a deciduous tree (meaning it loses its leaves in the fall) growing to about 15 feet tall." " The leaves are dark green in summer, turning a beautiful red in the fall. Cherry trees are known for their beauty, shade, and privacy.\n\n**Sale Price:** $75.00\n\n**Important Considerations for Growing" " Cherry Trees:**\n\n* **Climate:** Cherry trees prefer a cool, moist climate, and 93230 falls within a suitable range (USDA zones 4-9). However, it's always a good idea to" " check the specific microclimate of your property (sun exposure, drainage etc.).\n* **Soil:** They do best in sandy soil. If your soil is different, you may need to amend it to improve drainage.\n* **Pollination:** Many cherry varieties require a second, compatible cherry tree for proper pollination" ". Check the specific pollination needs of this variety before purchase if you want a significant cherry yield.\n\nThis cherry tree is a beautiful addition to any yard and will provide you with delicious cherries if you can meet its needs. Would you like to know more about its pollination requirements, or perhaps see if we have any other" " fruit trees suitable for your area?\n" ""
10. Vektorindex erstellen
Unser Dataset ist recht klein und die Antwortzeit hängt in erster Linie von der Interaktion mit KI-Modellen ab. Wenn Sie jedoch Millionen von Vektoren haben, kann die Vektorsuche einen erheblichen Teil unserer Antwortzeit in Anspruch nehmen und das System stark belasten. Zur Verbesserung können wir einen Index für unsere Vektoren erstellen.
ScaNN-Index erstellen
Zum Erstellen des SCANN-Indexes müssen wir noch eine weitere Erweiterung aktivieren. Die Erweiterung alloydb_scann bietet eine Schnittstelle für die Arbeit mit dem ANN-Vektorindex unter Verwendung des Google ScaNN-Algorithmus.
CREATE EXTENSION IF NOT EXISTS alloydb_scann;
Erwartete Ausgabe:
quickstart_db=> CREATE EXTENSION IF NOT EXISTS alloydb_scann; CREATE EXTENSION Time: 27.468 ms quickstart_db=>
Jetzt können wir den Index erstellen. Im folgenden Beispiel behalte ich die meisten Parameter als Standard bei und gebe nur eine bestimmte Anzahl von Partitionen (num_Leaves) für den Index an:
CREATE INDEX cymbal_products_embeddings_scann ON cymbal_products
USING scann (embedding cosine)
WITH (num_leaves=31, max_num_levels = 2);
Informationen zum Optimieren von Indexparametern finden Sie in der Dokumentation.
Erwartete Ausgabe:
quickstart_db=> CREATE INDEX cymbal_products_embeddings_scann ON cymbal_products USING scann (embedding cosine) WITH (num_leaves=31, max_num_levels = 2); CREATE INDEX quickstart_db=>
Antwort vergleichen
Jetzt können wir die Vektorsuchabfrage im Modus EXPLAIN ausführen und prüfen, ob der Index verwendet wurde.
EXPLAIN (analyze)
WITH trees as (
SELECT
cp.product_name,
left(cp.product_description,80) as description,
cp.sale_price,
cs.zip_code,
cp.uniq_id as product_id
FROM
cymbal_products cp
JOIN cymbal_inventory ci on
ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
cs.store_id=ci.store_id
AND ci.inventory>0
AND cs.store_id = 1583
ORDER BY
(cp.embedding <=> embedding('text-embedding-004','What kind of fruit trees grow well here?')::vector) ASC
LIMIT 1)
SELECT json_agg(trees) FROM trees;
Erwartete Ausgabe:
Aggregate (cost=16.59..16.60 rows=1 width=32) (actual time=2.875..2.877 rows=1 loops=1) -> Subquery Scan on trees (cost=8.42..16.59 rows=1 width=142) (actual time=2.860..2.862 rows=1 loops=1) -> Limit (cost=8.42..16.58 rows=1 width=158) (actual time=2.855..2.856 rows=1 loops=1) -> Nested Loop (cost=8.42..6489.19 rows=794 width=158) (actual time=2.854..2.855 rows=1 loops=1) -> Nested Loop (cost=8.13..6466.99 rows=794 width=938) (actual time=2.742..2.743 rows=1 loops=1) -> Index Scan using cymbal_products_embeddings_scann on cymbal_products cp (cost=7.71..111.99 rows=876 width=934) (actual time=2.724..2.724 rows=1 loops=1) Order By: (embedding <=> '[0.008864171,0.03693164,-0.024245683,-0.00355923,0.0055611245,0.015985578,...<redacted>...5685,-0.03914233,-0.018452475,0.00826032,-0.07372604]'::vector) -> Index Scan using walmart_inventory_pkey on cymbal_inventory ci (cost=0.42..7.26 rows=1 width=37) (actual time=0.015..0.015 rows=1 loops=1) Index Cond: ((store_id = 1583) AND (uniq_id = (cp.uniq_id)::text))
An der Ausgabe können wir deutlich erkennen, dass in der Abfrage „Index Scan using cymbal_products_embeddings_scann on cymbal_products“ verwendet wurde.
Wenn wir die Abfrage ohne „explain“ ausführen, erhalten wir Folgendes:
WITH trees as (
SELECT
cp.product_name,
left(cp.product_description,80) as description,
cp.sale_price,
cs.zip_code,
cp.uniq_id as product_id
FROM
cymbal_products cp
JOIN cymbal_inventory ci on
ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
cs.store_id=ci.store_id
AND ci.inventory>0
AND cs.store_id = 1583
ORDER BY
(cp.embedding <=> embedding('text-embedding-004','What kind of fruit trees grow well here?')::vector) ASC
LIMIT 1)
SELECT json_agg(trees) FROM trees;
Erwartete Ausgabe:
[{"product_name":"Meyer Lemon Tree","description":"Meyer Lemon trees are California's favorite lemon tree! Grow your own lemons by ","sale_price":34,"zip_code":93230,"product_id":"02056727942aeb714dc9a2313654e1b0"}]
Das Ergebnis ist etwas anders. Es wird nicht der Kirschbaum zurückgegeben, der bei der Suche ohne Index an erster Stelle stand, sondern die zweite Auswahl, der Meyer-Zitronenbaum. Der Index liefert uns also Leistung, ist aber dennoch genau genug, um gute Ergebnisse zu liefern.
Auf der Dokumentationsseite finden Sie verschiedene für die Vektoren verfügbare Indexe sowie weitere Labs und Beispiele mit LangChain-Integration.
11. Umgebung bereinigen
AlloyDB-Instanzen und ‑Cluster nach Abschluss des Labs löschen
AlloyDB-Cluster und alle Instanzen löschen
Der Cluster wird mit Option erzwungen, wodurch auch alle Instanzen gelöscht werden, die zum Cluster gehören.
Definieren Sie in Cloud Shell die Projekt- und Umgebungsvariablen, wenn die Verbindung getrennt wurde und alle vorherigen Einstellungen verloren gehen:
gcloud config set project <your project id>
export REGION=us-central1
export ADBCLUSTER=alloydb-aip-01
export PROJECT_ID=$(gcloud config get-value project)
Löschen Sie den Cluster:
gcloud alloydb clusters delete $ADBCLUSTER --region=$REGION --force
Erwartete Console-Ausgabe:
student@cloudshell:~ (test-project-001-402417)$ gcloud alloydb clusters delete $ADBCLUSTER --region=$REGION --force All of the cluster data will be lost when the cluster is deleted. Do you want to continue (Y/n)? Y Operation ID: operation-1697820178429-6082890a0b570-4a72f7e4-4c5df36f Deleting cluster...done.
AlloyDB-Sicherungen löschen
Löschen Sie alle AlloyDB-Sicherungen für den Cluster:
for i in $(gcloud alloydb backups list --filter="CLUSTER_NAME: projects/$PROJECT_ID/locations/$REGION/clusters/$ADBCLUSTER" --format="value(name)" --sort-by=~createTime) ; do gcloud alloydb backups delete $(basename $i) --region $REGION --quiet; done
Erwartete Konsolenausgabe:
student@cloudshell:~ (test-project-001-402417)$ for i in $(gcloud alloydb backups list --filter="CLUSTER_NAME: projects/$PROJECT_ID/locations/$REGION/clusters/$ADBCLUSTER" --format="value(name)" --sort-by=~createTime) ; do gcloud alloydb backups delete $(basename $i) --region $REGION --quiet; done Operation ID: operation-1697826266108-60829fb7b5258-7f99dc0b-99f3c35f Deleting backup...done.
Jetzt können wir die VM löschen.
GCE-VM löschen
Führen Sie in Cloud Shell folgenden Befehl aus:
export GCEVM=instance-1
export ZONE=us-central1-a
gcloud compute instances delete $GCEVM \
--zone=$ZONE \
--quiet
Erwartete Console-Ausgabe:
student@cloudshell:~ (test-project-001-402417)$ export GCEVM=instance-1
export ZONE=us-central1-a
gcloud compute instances delete $GCEVM \
--zone=$ZONE \
--quiet
Deleted
12. Glückwunsch
Herzlichen Glückwunsch zum Abschluss des Codelabs.
Behandelte Themen
- AlloyDB-Cluster und primäre Instanz bereitstellen
- Verbindung von einer Google Compute Engine-VM zu AlloyDB herstellen
- Datenbank erstellen und AlloyDB AI aktivieren
- Daten in die Datenbank laden
- Vertex AI-Embedding-Modell in AlloyDB verwenden
- Ergebnis mit dem generativen Vertex AI-Modell anreichern
- Leistung mithilfe des Vektorindex verbessern
13. Umfrage
Ausgabe: