1. Einführung
In diesem Codelab erfahren Sie, wie Sie AlloyDB AI 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
- So stellen Sie über eine Google Compute Engine-VM eine Verbindung zu AlloyDB her
- Datenbank erstellen und AlloyDB AI aktivieren
- Daten in die Datenbank laden
- Vertex AI-Embedding-Modell in AlloyDB verwenden
- Ergebnisse mit dem generativen Modell von Vertex AI ergänzen
- Leistung mithilfe eines Vektorindexes verbessern
Voraussetzungen
- Ein Google Cloud-Konto und ein Google Cloud-Projekt
- Einen Webbrowser wie Chrome
2. Einrichtung und Anforderungen
Einrichtung der Umgebung im eigenen Tempo
- 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 ein Konto erstellen.
- Der Projektname ist der Anzeigename für die Teilnehmer dieses Projekts. 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 kann nach der Festlegung 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 Ihr eigenes Konto ausprobieren und prüfen, ob es verfügbar ist. Sie kann nach diesem Schritt nicht mehr geändert werden und bleibt für die Dauer des Projekts bestehen. - Zur Information: Es gibt einen dritten Wert, die Projektnummer, die von einigen APIs verwendet wird. Weitere Informationen zu diesen drei Werten finden Sie in der Dokumentation.
- Als Nächstes müssen Sie in der Cloud Console die Abrechnung aktivieren, um Cloud-Ressourcen/-APIs verwenden zu können. Die Durchführung dieses Codelabs ist kostenlos oder kostet nur sehr wenig. Wenn Sie die Ressourcen deaktivieren möchten, um Kosten nach Abschluss dieser Anleitung zu vermeiden, können Sie die von Ihnen erstellten Ressourcen oder das Projekt löschen. Neuen Google Cloud-Nutzern steht das kostenlose Testprogramm mit einem Guthaben von 300$ zur Verfügung.
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 sollte nur wenige Minuten dauern. 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. Dadurch werden Netzwerkleistung und Authentifizierung erheblich verbessert. Alle Aufgaben in diesem Codelab können in einem Browser ausgeführt werden. Sie müssen nichts installieren.
3. Hinweis
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 Im 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 für den Zugriff auf private Dienste in unserer VPC für AlloyDB konfigurieren. Wir gehen davon aus, dass wir das Standard-VPC-Netzwerk im Projekt haben und es für alle Aktionen verwendet wird.
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
So 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 Console-Ausgabe:
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 ein eigenes Passwort definieren oder eine Zufallsfunktion verwenden, um eins zu 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 später:
echo $PGPASSWORD
Erwartete Console-Ausgabe:
student@cloudshell:~ (test-project-402417)$ echo $PGPASSWORD bbefbfde7601985b0dee5723
Geben Sie die Region und den Namen des AlloyDB-Clusters an. 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 Console-Ausgabe:
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. Verbindung zu AlloyDB herstellen
AlloyDB wird über eine ausschließlich private Verbindung bereitgestellt. Daher benötigen wir eine VM mit installiertem PostgreSQL-Client, um mit der Datenbank arbeiten zu können.
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 Console-Ausgabe:
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 den Befehl zum Ausführen der Software in der VM:
sudo apt-get update
sudo apt-get install --yes postgresql-client
Erwartete Console-Ausgabe:
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.
Auf demselben Cloud Shell-Tab mit der geöffneten SSH-Sitzung zu Ihrer VM „instance-1“.
Verwenden Sie das angegebene AlloyDB-Passwort (PGPASSWORD) und die AlloyDB-Cluster-ID, um von der GCE-VM aus eine Verbindung 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 Console-Ausgabe:
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.
AlloyDB die erforderlichen Berechtigungen erteilen
Fügen Sie dem AlloyDB-Dienst-Agent Vertex AI-Berechtigungen hinzu.
Öffnen Sie einen weiteren Cloud Shell-Tab über das Pluszeichen 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 entweder über den Befehl „exit“:
exit
Datenbank erstellen
Datenbank erstellen – Kurzanleitung
Führen Sie in der GCE-VM-Sitzung Folgendes aus:
Datenbank erstellen:
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 Console-Ausgabe:
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 Importieren der Daten haben wir unsere Produktdaten in der 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 unserer Produkte berechnen. Dazu verwenden wir die Funktion Embedding. Mit der Funktion verwenden wir die Vertex AI-Integration, um Vektordaten basierend auf unseren Produktbeschreibungen zu berechnen und der Tabelle hinzuzufügen. Weitere Informationen zur verwendeten Technologie finden Sie in der Dokumentation.
Embedding-Spalte 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 zurück, die auf den Daten aus der Spalte „product_description“ basieren.
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 jetzt eine Ähnlichkeitssuche mit den für die Beschreibungen berechneten Vektorwerten und dem Vektorwert ausführen, den wir für unsere Anfrage erhalten.
Die SQL-Abfrage kann über dieselbe psql-Befehlszeile oder alternativ über AlloyDB Studio ausgeführt werden. Mehrzeilige und komplexe Ausgaben sehen in AlloyDB Studio möglicherweise besser aus.
Verbindung zu AlloyDB Studio herstellen
In den folgenden Kapiteln können alle SQL-Befehle, für die eine Verbindung zur Datenbank erforderlich ist, 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. Wenn Sie die Befehle in der Datenbank ausführen möchten, klicken Sie rechts auf den Tab „Editor 1“.
Es wird eine Benutzeroberfläche geöffnet, in der Sie SQL-Befehle ausführen können.
Wenn Sie lieber die Befehlszeile psql verwenden möchten, gehen Sie wie in den vorherigen Kapiteln beschrieben vor und stellen Sie über die SSH-Sitzung Ihrer VM eine Verbindung zur Datenbank her.
Ähnlichkeitssuche über psql ausführen
Wenn die Verbindung zu Ihrer Datenbank getrennt wurde, stellen Sie sie mit psql oder AlloyDB Studio wieder her.
Stellen Sie eine Verbindung zur Datenbank her:
psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db"
Führe eine Abfrage aus, um eine Liste der verfügbaren Produkte zu erhalten, die der Anfrage eines Kunden am ehesten entsprechen. Die Anfrage, die wir an Vertex AI senden, um den Vektorwert zu erhalten, lautet: „Welche Obstbäume gedeihen hier gut?“
Mit dieser Abfrage können Sie die ersten 10 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 möchten wir eine JSON-Datei mit den Ergebnissen der Vektorsuche generieren und diese dann als Ergänzung zu einem Prompt für ein LLM-Modell für Text in Vertex AI verwenden, 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 diese Aufforderung ignorieren. Für dieses Lab benötigen wir keine zusätzlichen APIs.
Hier ist der Prompt, den wir verwenden werden:
Sie sind ein freundlicher Berater, der Kunden bei der Auswahl eines Produkts entsprechend ihren Anforderungen hilft.
Auf Grundlage der Kundenanfrage haben wir eine Liste mit Produkten geladen, die eng mit der Suche 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:
Im Folgenden sehen Sie die Antwort, die wir in diesem Beispiel vom Modell erhalten haben. Hinweis: Ihre Antwort kann aufgrund von Modell- und Parameteränderungen im Laufe der Zeit abweichen:
„Sie suchen also nach einem Baum, der in Ihrer Region gut gedeiht. Basierend auf Ihrer Postleitzahl 93230 scheint das Cherry Tree 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 Details zur Wachstumsrate in Ihrer Region, aber ich kann Ihnen sagen, dass Kirschbäume im Allgemeinen gut durchlässigen Boden und volle Sonne bevorzugen.
Für optimale Ergebnisse empfehlen wir Ihnen, sich an eine Gärtnerei oder einen Gartenexperten in Ihrer Nähe zu wenden, der Ihnen individuelle Beratung für Ihren Standort und Ihre Bodenbeschaffenheit geben 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
Mit der AlloyDB-KI-Integration in Vertex AI können wir dieselbe Antwort von einem generativen Modell mit SQL direkt in der Datenbank abrufen. 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 wie bereits gezeigt eine Verbindung von psql zur Datenbank „quickstart_db“ her (oder verwenden Sie AlloyDB Studio) und führen Sie Folgendes 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';
Als Nächstes 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 oder mit AlloyDB Studio prüfen, indem Sie eine Verbindung zur Datenbank „quickstart_db“ herstellen.
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 ist das bereits verwendete Modell text-embedding-004. Es muss registriert werden, da wir die Modellregistrierungsfunktionen aktiviert haben.
Führen Sie in psql oder AlloyDB Studio den folgenden Code aus, um das Modell zu registrieren:
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. Es wird verwendet, um die nutzerfreundliche Ausgabe zu generieren.
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 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 das in einer untergeordneten Abfrage generierte JSON als Teil des Prompts für das generative KI-Textmodell mit SQL bereitstellen.
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 Datenbestand ist recht klein und die Antwortzeit hängt hauptsächlich von der Interaktion mit KI-Modellen ab. Bei Millionen von Vektoren kann die Vektorsuche jedoch einen erheblichen Teil der Antwortzeit in Anspruch nehmen und das System stark belasten. Um das zu verbessern, können wir einen Index auf unseren 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 mit dem 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 belasse ich die meisten Parameter auf den Standardwerten und gebe nur die Anzahl der 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))
In der Ausgabe ist deutlich zu sehen, dass für die 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 Option, der Meyer-Zitronenbaum. Der Index liefert also Leistung, ist aber dennoch genau genug, um gute Ergebnisse zu erzielen.
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 der Option „force“ gelöscht. Dadurch werden auch alle zugehörigen Instanzen gelöscht.
Definieren Sie in Cloud Shell die Projekt- und Umgebungsvariablen, wenn die Verbindung getrennt wurde und alle vorherigen Einstellungen verloren gegangen sind:
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 Console-Ausgabe:
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 Folgendes 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
- So stellen Sie über eine Google Compute Engine-VM eine Verbindung zu AlloyDB her
- Datenbank erstellen und AlloyDB AI aktivieren
- Daten in die Datenbank laden
- Vertex AI-Embedding-Modell in AlloyDB verwenden
- Ergebnisse mit dem generativen Modell von Vertex AI ergänzen
- Leistung mithilfe eines Vektorindexes verbessern
13. Umfrage
Ausgabe: