Diese Seite wurde von der Cloud Translation API übersetzt.

Erste Schritte mit Vektoreinbettungen mit AlloyDB AI

1. Einführung

In diesem Codelab erfahren Sie, wie Sie AlloyDB AI verwenden, indem Sie die Vektorsuche mit Vertex AI-Einbettungen kombinieren.

Voraussetzungen

Grundlegendes Verständnis der Google Cloud Console
Grundkenntnisse in der Befehlszeile und in Google Shell

Aufgaben in diesem Lab

AlloyDB-Cluster und primäre Instanz bereitstellen
Verbindung von der Google Compute Engine-VM zu AlloyDB herstellen
Datenbank erstellen und AlloyDB AI aktivieren
Daten in die Datenbank laden
Vertex AI-Einbettungsmodell in AlloyDB verwenden
Ergebnis mit dem generativen Vertex AI-Modell anreichern

Voraussetzungen

Ein Google Cloud-Konto und ein Google Cloud-Projekt
Ein 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 Projekt. 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 handelt sich um eine Zeichenfolge, die von Google APIs nicht verwendet wird. Sie können sie 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. Die Cloud Console generiert automatisch einen eindeutigen String. ist Ihnen meist egal, was es ist. In den meisten Codelabs musst du auf deine Projekt-ID verweisen, die üblicherweise als PROJECT_ID bezeichnet wird. Wenn Ihnen die generierte ID nicht gefällt, können Sie eine weitere zufällige ID 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 erhalten.
Zur Information gibt es noch einen dritten Wert, die Projektnummer, die von manchen APIs verwendet wird. Weitere Informationen zu allen 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. Dieses Codelab ist kostengünstig. Sie können die von Ihnen erstellten Ressourcen oder das Projekt löschen, um Ressourcen herunterzufahren, um zu vermeiden, dass über diese Anleitung hinaus Kosten anfallen. Neue Google Cloud-Nutzer haben Anspruch auf das kostenlose Testprogramm mit 300$Guthaben.

Cloud Shell starten

Sie können Google Cloud zwar von Ihrem Laptop aus der Ferne bedienen, 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 er abgeschlossen ist, sollten Sie in etwa Folgendes sehen:

Diese virtuelle Maschine verfügt über sämtliche Entwicklertools, die Sie benötigen. Es bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft auf Google Cloud, wodurch die Netzwerkleistung und Authentifizierung erheblich verbessert werden. Alle Arbeiten in diesem Codelab können in einem Browser erledigt 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 für die Verwendung der Vertex AI-Einbettungsmodelle. 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 Sie einen AlloyDB-Cluster erstellen, benötigen wir einen verfügbaren privaten IP-Bereich in unserer VPC, der von der zukünftigen AlloyDB-Instanz verwendet wird. Wenn nicht, müssen wir sie erstellen, sie zur Verwendung durch interne Google-Dienste zuweisen und anschließend 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“.

Definieren Sie ein Passwort für den Postgres-Nutzer. Sie können ein eigenes Passwort festlegen oder es mithilfe einer Zufallsfunktion generieren

export PGPASSWORD=`openssl rand -hex 12`

Erwartete Konsolenausgabe:

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 folgenden Befehl aus, um den Cluster zu erstellen:

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 eine primäre AlloyDB-Instanz für den Cluster in derselben Cloud Shell-Sitzung. Wenn die Verbindung getrennt wird, 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 Konsolenausgabe:

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 VPC wie der AlloyDB-Cluster.

Führen Sie in Cloud Shell folgenden Befehl 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 Konsolenausgabe:

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 zur primären Instanz her.

Öffnen Sie im selben Cloud Shell-Tab die geöffnete SSH-Sitzung mit Ihrer 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 folgenden Befehl 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 Konsolenausgabe:

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

Kurzanleitung zum Erstellen einer Datenbank.

Führen Sie in der GCE-VM-Sitzung Folgendes aus:

Datenbank erstellen:

psql "host=$INSTANCE_IP user=postgres" -c "CREATE DATABASE quickstart_db"

Erwartete Konsolenausgabe:

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 in der GCE-VM folgenden Befehl 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 Konsolenausgabe:

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 in der GCE-VM folgenden Befehl 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.

Spalte für Einbettung erstellen

Stellen Sie mithilfe von 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 dem Herstellen einer Verbindung zur Datenbank den folgenden Befehl aus:

ALTER TABLE cymbal_products ADD COLUMN embedding vector GENERATED ALWAYS AS (embedding('text-embedding-004',product_description)) STORED;

Der Befehl erstellt die virtuelle Spalte und füllt sie mit Vektordaten.

Erwartete Konsolenausgabe:

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 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. Zum Ausführen des Befehls müssen Sie die Benutzeroberfläche der 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 beim Erstellen des Clusters notiert wurde. Klicken Sie dann auf die Schaltfläche Schaltfläche.

Dadurch wird die AlloyDB Studio-Oberfläche 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 Datenbanksitzung getrennt wurde, stellen Sie über psql oder AlloyDB Studio wieder eine Verbindung zur Datenbank 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 übergeben, um den Vektorwert zu erhalten, klingt wie „Welche Art von Obstbäumen wachsen 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.287184013172779
 Toyon               | This is a beautiful toyon tree that can grow to be over 20 feet tall. It is an e |      10.00 |    93230 | 0.30574073611569963
 Secateurs           | These secateurs are perfect for pruning small branches and vines.                |      15.00 |    93230 |  0.3264385326189635
 Trimming Shears     | These trimming shears are perfect for trimming hedges and bushes.                |      20.00 |    93230 | 0.33293036535756393
 Cypress Tree        | This is a beautiful cypress tree that will provide shade and privacy. It is an e |      75.00 |    93230 | 0.33485770716129326
 Madrone             | This is a beautiful madrona tree that can grow to be over 80 feet tall. It is an |      50.00 |    93230 |  0.3354408801293012
 California Redwood  | This is a beautiful redwood tree that can grow to be over 300 feet tall. It is a |    1000.00 |    93230 |  0.3427243109636263
 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.3427628377929176
 California Sycamore | This is a beautiful sycamore tree that can grow to be over 100 feet tall. It is  |     300.00 |    93230 |  0.3430208475356905
 Maple Tree          | This is a beautiful maple tree that will produce colorful leaves in the fall. It |     100.00 |    93230 |  0.3432609589330091
(10 rows)

quickstart_db=>

9. Antwort verbessern

Sie können die Antwort auf eine Clientanwendung mithilfe des Ergebnisses der Abfrage verbessern und mithilfe der bereitgestellten Abfrageergebnisse als Teil des Prompts für das generative Foundation Language Model von Vertex AI eine aussagekräftige Ausgabe vorbereiten.

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 den JSON-Code, testen ihn dann in Vertex AI Studio und binden ihn 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 und nur eine Zeile zurückgegeben wird, die an Vertex AI übergeben werden soll

Hier ist das 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 der erwartete JSON-Code in der 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 verwenden, um sie als Teil des Prompts für das Generative AI-Textmodell in Vertex AI Studio bereitzustellen

Ö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 der Prompt, den wir verwenden:

Sie sind ein freundlicher Berater, der Ihnen dabei hilft, ein Produkt zu finden, das zu den Anforderungen des Kunden passt.

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:

[Ort für unsere JSON-Datei]

Der Kunde fragte: „Welcher Baum wächst hier am besten?“

Sie sollten Informationen zum Produkt und zum Preis sowie einige zusätzliche Informationen angeben.“ als Prompt

Und hier ist das Ergebnis, wenn wir den Prompt mit unseren JSON-Werten ausführen und das Modell „gemini-1.5-flash“ verwenden:

Die Antwort, die wir in diesem Beispiel vom Modell erhalten haben, folgt. Beachten Sie, dass Ihre Antwort aufgrund von Änderungen des Modells und der Parameter im Laufe der Zeit abweichen kann:

„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 ein wunderschöner Baum beschrieben, der köstliche Kirschen produziert. Es ist derzeit im Angebot für 75,00 €.

Obwohl ich keine konkreten Details zur Wachstumsrate in deiner Region habe, kann ich dir sagen, dass Kirschbäume in der Regel gut durchlässigen Boden und volle Sonneneinstrahlung bevorzugen.

Um optimale Ergebnisse zu erzielen, empfehle ich dir, dich an eine Gärtnerei oder einen Gartenexperte vor Ort zu wenden, der dich besser auf deinen spezifischen Standort und deine Bodenbedingungen beraten kann. Er kann dir auch dabei helfen, die beste Sorte für deine Bedürfnisse auszuwählen, und gibt Tipps für Pflanzen und Pflege.“

Eingabeaufforderung 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 zu verwenden, müssen wir es jedoch zuerst registrieren.

Aktualisieren Sie die Erweiterung auf Version 1.3. Stellen Sie über pSQL wie zuvor eine Verbindung zur Datenbank „quickstart_db“ her (oder verwenden Sie AlloyDB Studio) und führen Sie den folgenden Befehl aus:

ALTER EXTENSION google_ml_integration UPDATE TO '1.3'

Dann müssen wir das Datenbank-Flag „google_ml_integration.enable_model_support“ auf „on“ setzen. Dazu können Sie die AlloyDB-Webkonsole verwenden oder den folgenden gcloud-Befehl ausführen.

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

Es dauert etwa 3 bis 5 Minuten, bis der Befehl im Hintergrund ausgeführt wird. 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 aktiviert:

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 die Funktionen zur Modellregistrierung aktiviert wurden.

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-001, mit dem die benutzerfreundliche Ausgabe generiert wird.

CALL
  google_ml.create_model(
    model_id => 'gemini-1.5-flash-001',
    model_request_url => 'https://$REGION-aiplatform.googleapis.com/v1/projects/$PROJECT_ID/locations/$REGION/publishers/google/models/gemini-1.5-flash-001: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 ist 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 mithilfe von 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-001',
        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. Ihre Ausgabe kann je nach Modellversion und Parametern unterschiedlich ausfallen:

--------------------------------------------------------------------------------------------------------
 "I" " see you're interested in fruit trees! Based on your location, I found" " one great option:\n\n**Cherry Tree:** \n\nThis beautiful cherry tree will" " produce delicious cherries. It's a deciduous tree, meaning it loses its leaves in the fall, and can grow up to 15 feet tall. The" " leaves are a vibrant dark green in the summer, turning a beautiful red in the fall. \n\nCherry trees are known for their beauty and ability to provide shade" " and privacy. They prefer a cool, moist climate and sandy soil, making them a good fit for your area. \n\nThe Cherry Tree is currently on sale for $75.00.\n\nWould you like to know more about" " the Cherry Tree, or are you interested in exploring other fruit tree options? \n" ""
(1 row)

10. Umgebung bereinigen

AlloyDB-Instanzen und -Cluster löschen, wenn Sie mit dem Lab fertig sind

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 Konsolenausgabe:

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 unsere 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 Konsolenausgabe:

student@cloudshell:~ (test-project-001-402417)$ export GCEVM=instance-1
export ZONE=us-central1-a
gcloud compute instances delete $GCEVM \
    --zone=$ZONE \
    --quiet
Deleted

11. Glückwunsch

Herzlichen Glückwunsch zum Abschluss des Codelabs.

Behandelte Themen

AlloyDB-Cluster und primäre Instanz bereitstellen
Verbindung von der Google Compute Engine-VM zu AlloyDB herstellen
Datenbank erstellen und AlloyDB AI aktivieren
Daten in die Datenbank laden
Vertex AI-Einbettungsmodell in AlloyDB verwenden
Ergebnis mit dem generativen Vertex AI-Modell anreichern

12. Umfrage

Ausgabe:

Wie möchten Sie diese Anleitung nutzen?

<ph type="x-smartling-placeholder"></ph> Lesen Sie sie nur durch.

Lies sie dir durch und absolviere die Übungen