1. Einführung
In diesem Codelab erfahren Sie, wie Sie AlloyDB Omni in der GKE bereitstellen und mit einem offenen Einbettungsmodell verwenden, das im selben Kubernetes-Cluster bereitgestellt ist. Die Bereitstellung eines Modells neben der Datenbankinstanz im selben GKE-Cluster reduziert die Latenz und die Abhängigkeiten von Drittanbieterdiensten. Außerdem kann die lokale Bereitstellung eine Anforderung sein, die von den Sicherheits- und Compliance-Richtlinien festgelegt wird, wenn die Daten das Unternehmen nicht verlassen dürfen und die Nutzung von Drittanbieterdiensten nicht zulässig ist.
Voraussetzungen
- Grundkenntnisse in Google Cloud und der Google Cloud Console
- Grundkenntnisse in Kubernetes und GKE
- Grundkenntnisse in der Befehlszeile und Cloud Shell
Lerninhalte
- AlloyDB Omni in einem Google Kubernetes-Cluster bereitstellen
- Verbindung zu AlloyDB Omni herstellen
- Daten in AlloyDB Omni laden
- Offenes Embedding-Modell in GKE bereitstellen
- Einbettungsmodell in AlloyDB Omni registrieren
- Einbettungen für die semantische Suche generieren
- Generierte Einbettungen für die semantische Suche in AlloyDB Omni verwenden
- Vektorindexe in AlloyDB erstellen und verwenden
Voraussetzungen
- Ein Google Cloud-Konto und ein Google Cloud-Projekt
- Ein Webbrowser wie Chrome, der die Google Cloud Console und die Cloud Shell unterstützt
2. Einrichtung und Anforderungen
Projekteinrichtung
- Melden Sie sich in der Google Cloud Console an. Wenn Sie noch kein Gmail- oder Google Workspace-Konto haben, müssen Sie eines erstellen.
Verwenden Sie ein privates Konto anstelle eines Arbeitskontos oder eines Kontos einer Bildungseinrichtung.
- Erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes. Klicken Sie zum Erstellen eines neuen Projekts in der Google Cloud Console in der Kopfzeile auf die Schaltfläche „Projekt auswählen“, um ein Pop-up-Fenster zu öffnen.
Klicken Sie im Fenster „Projekt auswählen“ auf die Schaltfläche „Neues Projekt“. Daraufhin wird ein Dialogfeld für das neue Projekt geöffnet.
Geben Sie im Dialogfeld den gewünschten Projektnamen ein und wählen Sie den Speicherort aus.
- Der Projektname ist der Anzeigename für die Teilnehmer dieses Projekts. Der Projektname wird von Google APIs nicht verwendet und kann jederzeit geändert werden.
- Die Projekt-ID ist für alle Google Cloud-Projekte eindeutig und unveränderlich. Sie kann also nicht mehr geändert werden, nachdem sie festgelegt wurde. In der Google Cloud Console wird automatisch eine eindeutige ID generiert, die Sie aber anpassen können. Wenn Ihnen die generierte ID nicht gefällt, können Sie eine weitere zufällige ID generieren oder eine eigene ID angeben, um die Verfügbarkeit zu prüfen. In den meisten Codelabs müssen Sie auf Ihre Projekt-ID verweisen, die in der Regel mit dem Platzhalter PROJECT_ID angegeben wird.
- Zur Information: Es gibt einen dritten Wert, die Projektnummer, die von einigen APIs verwendet wird. Weitere Informationen zu diesen drei Werten
Abrechnung aktivieren
Privates Rechnungskonto einrichten
Wenn Sie die Abrechnung mit Google Cloud-Guthaben einrichten, können Sie diesen Schritt überspringen.
Hier können Sie die Abrechnung in der Cloud Console aktivieren, um ein privates Rechnungskonto einzurichten.
Hinweise:
- Die Cloud-Ressourcen, die Sie für dieses Lab benötigen, sollten weniger als 3 $kosten.
- Sie können die Schritte am Ende dieses Labs ausführen, um Ressourcen zu löschen und so weitere Kosten zu vermeiden.
- Neue Nutzer haben Anspruch auf den kostenlosen Testzeitraum mit einem Guthaben von 300$.
Cloud Shell starten
Während Sie Google Cloud von Ihrem Laptop aus per Fernzugriff nutzen können, wird in diesem Codelab Google Cloud Shell verwendet, 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:
Alternativ können Sie auch G und dann S drücken. Mit dieser Sequenz wird Cloud Shell aktiviert, wenn Sie sich in der Google Cloud Console befinden oder diesen Link verwenden.
Die Bereitstellung und Verbindung mit der Umgebung sollte nur wenige Augenblicke dauern. Anschließend sehen Sie in etwa Folgendes:
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 in Google Cloud, was die 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:
Wenn Sie Google Kubernetes Engine (GKE) für AlloyDB Omni und Bereitstellungen offener Modelle verwenden möchten, müssen Sie die entsprechenden APIs in Ihrem Google Cloud-Projekt aktivieren.
Prüfen Sie in Cloud Shell, ob Ihre Projekt-ID eingerichtet ist:
PROJECT_ID=$(gcloud config get-value project)
echo $PROJECT_ID
Wenn sie nicht in der Cloud Shell-Konfiguration definiert ist, richten Sie sie mit den folgenden Befehlen ein.
export PROJECT_ID=<your project>
gcloud config set project $PROJECT_ID
Aktivieren Sie alle erforderlichen Dienste:
gcloud services enable compute.googleapis.com
gcloud services enable container.googleapis.com
Erwartete Ausgabe
student@cloudshell:~ (test-project-001-402417)$ PROJECT_ID=test-project-001-402417 student@cloudshell:~ (test-project-001-402417)$ gcloud config set project test-project-001-402417 Updated property [core/project]. student@cloudshell:~ (test-project-001-402417)$ gcloud services enable compute.googleapis.com gcloud services enable container.googleapis.com Operation "operations/acat.p2-4470404856-1f44ebd8-894e-4356-bea7-b84165a57442" finished successfully.
Einführung in die APIs
- Mit der Kubernetes Engine API (
container.googleapis.com) können Sie Google Kubernetes Engine-Cluster (GKE) erstellen und verwalten. GKE bietet eine verwaltete Umgebung für das Deployment, die Verwaltung und die Skalierung von containerisierten Anwendungen in der Google-Infrastruktur. - Mit der Compute Engine API (
compute.googleapis.com) können Sie virtuelle Maschinen (VMs), nichtflüchtige Speicher und Netzwerkeinstellungen erstellen und verwalten. Sie bietet die erforderliche IaaS-Grundlage (Infrastructure-as-a-Service) für die Ausführung Ihrer Arbeitslasten und das Hosting der zugrunde liegenden Infrastruktur für viele verwaltete Dienste.
4. AlloyDB Omni in GKE bereitstellen
Wenn Sie AlloyDB Omni in GKE bereitstellen möchten, müssen Sie einen Kubernetes-Cluster vorbereiten, der den in den Anforderungen für den AlloyDB Omni-Operator aufgeführten Anforderungen entspricht.
GKE-Cluster erstellen
Wir müssen einen GKE-Standardcluster mit einer Poolkonfiguration bereitstellen, die für die Bereitstellung eines Pods mit einer AlloyDB Omni-Instanz ausreicht. Für AlloyDB Omni benötigen wir mindestens 2 CPUs und 8 GB RAM und etwas Platz für Operator- und Monitoring-Dienstcontainer. Wir verwenden den VM-Typ e2-standard-4.
Richten Sie die Umgebungsvariablen für Ihre Bereitstellung ein.
export PROJECT_ID=$(gcloud config get project)
export LOCATION=us-central1
export CLUSTER_NAME=alloydb-ai-gke
export MACHINE_TYPE=e2-standard-4
Anschließend erstellen wir den GKE-Standardcluster mit gcloud.
gcloud container clusters create ${CLUSTER_NAME} \
--project=${PROJECT_ID} \
--region=${LOCATION} \
--workload-pool=${PROJECT_ID}.svc.id.goog \
--release-channel=rapid \
--machine-type=${MACHINE_TYPE} \
--num-nodes=1
Erwartete Konsolenausgabe:
student@cloudshell:~ (gleb-test-short-001-415614)$ export PROJECT_ID=$(gcloud config get project)
export LOCATION=us-central1
export CLUSTER_NAME=alloydb-ai-gke
export MACHINE_TYPE=n2-highmem-2
Your active configuration is: [gleb-test-short-001-415614]
student@cloudshell:~ (gleb-test-short-001-415614)$ gcloud container clusters create ${CLUSTER_NAME} \
--project=${PROJECT_ID} \
--region=${LOCATION} \
--workload-pool=${PROJECT_ID}.svc.id.goog \
--release-channel=rapid \
--machine-type=${MACHINE_TYPE} \
--num-nodes=1
Note: The Kubelet readonly port (10255) is now deprecated. Please update your workloads to use the recommended alternatives. See https://cloud.google.com/kubernetes-engine/docs/how-to/disable-kubelet-readonly-port for ways to check usage and for migration instructions.
Note: Your Pod address range (`--cluster-ipv4-cidr`) can accommodate at most 1008 node(s).
Creating cluster alloydb-ai-gke in us-central1..
NAME: omni01
ZONE: us-central1-a
MACHINE_TYPE: e2-standard-4
PREEMPTIBLE:
INTERNAL_IP: 10.128.0.3
EXTERNAL_IP: 35.232.157.123
STATUS: RUNNING
student@cloudshell:~ (gleb-test-short-001-415614)$
Cluster vorbereiten
Wir müssen erforderliche Komponenten wie den Cert-Manager-Dienst installieren – den nativen Zertifikatsmanager für Kubernetes. Wir können die Schritte in der Dokumentation zur Installation von cert-manager ausführen.
Wir verwenden das Kubernetes-Befehlszeilentool kubectl, das standardmäßig bereits in Cloud Shell installiert ist. Bevor wir das Tool verwenden können, müssen wir Anmeldedaten für unseren Cluster abrufen.
gcloud container clusters get-credentials ${CLUSTER_NAME} --region=${LOCATION}
Jetzt können wir kubectl verwenden, um cert-manager zu installieren:
kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.19.2/cert-manager.yaml
Erwartete Konsolenausgabe(redigiert):
student@cloudshell:~$ kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.16.2/cert-manager.yaml namespace/cert-manager created customresourcedefinition.apiextensions.k8s.io/certificaterequests.cert-manager.io created customresourcedefinition.apiextensions.k8s.io/certificates.cert-manager.io created customresourcedefinition.apiextensions.k8s.io/challenges.acme.cert-manager.io created customresourcedefinition.apiextensions.k8s.io/clusterissuers.cert-manager.io created ... validatingwebhookconfiguration.admissionregistration.k8s.io/cert-manager-webhook created
AlloyDB Omni installieren
Der AlloyDB Omni-Operator kann mit dem Helm-Dienstprogramm installiert werden.
Führen Sie den folgenden Befehl aus, um den AlloyDB Omni-Operator zu installieren:
export GCS_BUCKET=alloydb-omni-operator
export HELM_PATH=$(gcloud storage cat gs://$GCS_BUCKET/latest)
export OPERATOR_VERSION="${HELM_PATH%%/*}"
gcloud storage cp gs://$GCS_BUCKET/$HELM_PATH ./ --recursive
helm install alloydbomni-operator alloydbomni-operator-${OPERATOR_VERSION}.tgz \
--create-namespace \
--namespace alloydb-omni-system \
--atomic \
--timeout 5m
Erwartete Konsolenausgabe(redigiert):
student@cloudshell:~$ gcloud storage cp gs://$GCS_BUCKET/$HELM_PATH ./ --recursive
Copying gs://alloydb-omni-operator/1.2.0/alloydbomni-operator-1.2.0.tgz to file://./alloydbomni-operator-1.2.0.tgz
Completed files 1/1 | 126.5kiB/126.5kiB
student@cloudshell:~$ helm install alloydbomni-operator alloydbomni-operator-${OPERATOR_VERSION}.tgz \
> --create-namespace \
> --namespace alloydb-omni-system \
> --atomic \
> --timeout 5m
NAME: alloydbomni-operator
LAST DEPLOYED: Mon Jan 20 13:13:20 2025
NAMESPACE: alloydb-omni-system
STATUS: deployed
REVISION: 1
TEST SUITE: None
student@cloudshell:~$
Nachdem der AlloyDB Omni-Operator installiert wurde, können wir mit der Bereitstellung unseres Datenbankclusters fortfahren.
Hier ist ein Beispiel für ein Bereitstellungsmanifest mit aktiviertem Parameter „googleMLExtension“ und einem internen (privaten) Load Balancer:
apiVersion: v1
kind: Secret
metadata:
name: db-pw-my-omni
type: Opaque
data:
my-omni: "VmVyeVN0cm9uZ1Bhc3N3b3Jk"
---
apiVersion: alloydbomni.dbadmin.goog/v1
kind: DBCluster
metadata:
name: my-omni
spec:
databaseVersion: "15.13.0"
primarySpec:
adminUser:
passwordRef:
name: db-pw-my-omni
features:
googleMLExtension:
enabled: true
resources:
cpu: 1
memory: 8Gi
disks:
- name: DataDisk
size: 20Gi
storageClass: standard
dbLoadBalancerOptions:
annotations:
networking.gke.io/load-balancer-type: "internal"
allowExternalIncomingTraffic: true
Der Secret-Wert für das Passwort ist eine Base64-Darstellung des Passworts „VeryStrongPassword“. Die zuverlässigere Methode besteht darin, den Passwortwert mit Google Secret Manager zu speichern. Weitere Informationen finden Sie in der Dokumentation.
Speichern Sie das Manifest als my-omni.yaml, um es im nächsten Schritt anzuwenden. Wenn Sie sich in Cloud Shell befinden, können Sie den Editor verwenden. Klicken Sie dazu oben rechts im Terminal auf die Schaltfläche „Editor öffnen“.
Nachdem Sie die Datei unter dem Namen my-omni.yaml gespeichert haben, kehren Sie zum Terminal zurück, indem Sie auf die Schaltfläche „Terminal öffnen“ klicken.
Wenden Sie das Manifest my-omni.yaml mit dem kubectl-Tool auf den Cluster an:
kubectl apply -f my-omni.yaml
Erwartete Konsolenausgabe:
secret/db-pw-my-omni created dbcluster.alloydbomni.dbadmin.goog/my-omni created
Prüfen Sie den Status Ihres my-omni-Clusters mit dem kubectl-Tool:
kubectl get dbclusters.alloydbomni.dbadmin.goog my-omni -n default
Während der Bereitstellung durchläuft der Cluster verschiedene Phasen und sollte schließlich den Status DBClusterReady erreichen.
Erwartete Konsolenausgabe:
$ kubectl get dbclusters.alloydbomni.dbadmin.goog my-omni -n default NAME PRIMARYENDPOINT PRIMARYPHASE DBCLUSTERPHASE HAREADYSTATUS HAREADYREASON my-omni 10.131.0.33 Ready DBClusterReady
Verbindung zu AlloyDB Omni herstellen
Verbindung über Kubernetes-Pod herstellen
Wenn der Cluster bereit ist, können wir die PostgreSQL-Clientbinärdateien im Pod der AlloyDB Omni-Instanz verwenden. Wir ermitteln die Pod-ID und verwenden dann „kubectl“, um eine direkte Verbindung zum Pod herzustellen und die Clientsoftware auszuführen. Das Passwort ist VeryStrongPassword, wie über das Kubernetes-Secret im Manifest „my-omni.yaml“ festgelegt:
DB_CLUSTER_NAME=my-omni
DB_CLUSTER_NAMESPACE=default
DBPOD=`kubectl get pod --selector=alloydbomni.internal.dbadmin.goog/dbcluster=$DB_CLUSTER_NAME,alloydbomni.internal.dbadmin.goog/task-type=database -n $DB_CLUSTER_NAMESPACE -o jsonpath='{.items[0].metadata.name}'`
kubectl exec -ti $DBPOD -n $DB_CLUSTER_NAMESPACE -c database -- psql -h localhost -U postgres
Beispiel für die Konsolenausgabe:
DB_CLUSTER_NAME=my-omni
DB_CLUSTER_NAMESPACE=default
DBPOD=`kubectl get pod --selector=alloydbomni.internal.dbadmin.goog/dbcluster=$DB_CLUSTER_NAME,alloydbomni.internal.dbadmin.goog/task-type=database -n $DB_CLUSTER_NAMESPACE -o jsonpath='{.items[0].metadata.name}'`
kubectl exec -ti $DBPOD -n $DB_CLUSTER_NAMESPACE -c database -- psql -h localhost -U postgres
Password for user postgres:
psql (15.7)
SSL connection (protocol: TLSv1.3, cipher: TLS_AES_128_GCM_SHA256, compression: off)
Type "help" for help.
postgres=#
5. KI-Modell in GKE bereitstellen
Um die AlloyDB Omni-KI-Integration mit lokalen Modellen zu testen, müssen wir ein Modell im Cluster bereitstellen. Wir verwenden das Modell EmbeddingGemma von Google.
Knotenpool für das Modell erstellen
Damit wir das Modell ausführen können, müssen wir einen Knotenpool für die Inferenz vorbereiten. Wir können sie in einem Pool mit ausschließlich CPUs oder in einem Pool mit GPU-Beschleunigern ausführen. Der reine CPU-Ansatz ist in einigen Regionen aufgrund der hohen Parallelität für die Ressourcen möglicherweise besser geeignet. In unserem Lab verwenden wir den CPU-Ansatz. Der beste Ansatz aus Leistungssicht ist jedoch ein Pool mit Grafikbeschleunigern, der eine Knotenkonfiguration wie „g2-standard-8“ mit einem L4-Nvidia-Beschleuniger verwendet.
CPU-basierter Knotenpool
Erstellen Sie einen Knotenpool mit e2-standard-32-Knoten. Wir beschränken den Pull auf einen Knoten, um Ressourcen zu sparen.
export PROJECT_ID=$(gcloud config get project)
export LOCATION=us-central1
export CLUSTER_NAME=alloydb-ai-gke
gcloud container node-pools create cpupool \
--project=${PROJECT_ID} \
--location=${LOCATION} \
--node-locations=${LOCATION}-a \
--cluster=${CLUSTER_NAME} \
--machine-type=c3-standard-8 \
--num-nodes=1
Erwartete Ausgabe
student@cloudshell$ export PROJECT_ID=$(gcloud config get project)
Your active configuration is: [pant]
export LOCATION=us-central1
export CLUSTER_NAME=alloydb-ai-gke
student@cloudshell$ gcloud container node-pools create cpupool \
> --project=${PROJECT_ID} \
> --location=${LOCATION} \
> --node-locations=${LOCATION}-a \
> --cluster=${CLUSTER_NAME} \
> --machine-type=c3-standard-8 \
> --num-nodes=1
Creating node pool cpupool...done.
Created [https://container.googleapis.com/v1/projects/gleb-test-short-003-483115/zones/us-central1/clusters/alloydb-ai-gke/nodePools/cpupool].
NAME MACHINE_TYPE DISK_SIZE_GB NODE_VERSION
cpupool c3-standard-8 100 1.34.1-gke.3355002
Hugging Face-Token abrufen
In diesem Lab verwenden wir eine Partnerschaft mit Hugging Face, um das EmbeddingGemma-Modell bereitzustellen. Dazu benötigen wir ein Hugging Face-Token.
Führen Sie die folgenden Schritte aus, um ein neues Token zu generieren, falls Sie noch keines haben.
- Melden Sie sich auf der Hugging Face-Website an oder registrieren Sie sich dort. Verwenden Sie dazu die Links „Log In“ (Anmelden) oder „Sign Up“ (Registrieren) oben rechts.
- Klicken Sie auf „Mein Profil“ -> „Zugriffstokens“.
- Identität bestätigen
- Klicken Sie auf „Neues Token erstellen“.
- Wählen Sie einen Namen für Ihr Token aus.
- Wählen Sie eine Rolle für das Token aus. Sie benötigen mindestens die Berechtigung „Lesen“.
- Klicken Sie unten auf der Seite auf „Token erstellen“.
- Generiertes Token kopieren und zur späteren Verwendung speichern
Außerdem müssen Sie die Bedingungen für den Zugriff auf Dateien und Inhalte im Zusammenhang mit EmbeddingGemma auf Hugging Face auf der Seite https://huggingface.co/google/embeddinggemma-300m akzeptieren.
Kubernetes-Secret mit dem Token erstellen
Führen Sie in der Cloud Shell-Sitzung den folgenden Befehl aus (ersetzen Sie den Wert für HF_TOKEN durch Ihr HF-Token).
export HF_TOKEN=hf_QjgW...lfrXF
kubectl create secret generic hf-secret \
--from-literal=hf_api_token=$HF_TOKEN \
--dry-run=client -o yaml | kubectl apply -f -
Bereitstellungsmanifest vorbereiten
Um das Modell bereitzustellen, müssen wir ein Bereitstellungsmanifest vorbereiten.
Wir verwenden das EmbeddingGemma-Modell von Google aus Hugging Face. Die Modellkarte finden Sie hier. Für die Bereitstellung des Modells verwenden wir einen Ansatz, der auf der Anleitung von Hugging Face und dem Bereitstellungspaket von GitHub basiert.
Paket aus GitHub klonen
git clone https://github.com/huggingface/Google-Cloud-Containers
Manifest für TEI (Text Embedding Interface) auf CPU-Knoten anpassen Wir müssen mehrere Parameter ersetzen, darunter das Modell, das Bild und die korrekte Ressourcenzuweisung, und das Hugging Face-Token-Secret zur Konfiguration hinzufügen.
Manifest bearbeiten (mit einem beliebigen verfügbaren Editor)
vi Google-Cloud-Containers/examples/gke/tei-deployment/cpu-config/deployment.yaml
Hier ist ein korrigiertes Manifest für das Deployment in einem CPU-basierten Pool.
apiVersion: apps/v1
kind: Deployment
metadata:
name: tei-deployment
spec:
replicas: 1
selector:
matchLabels:
app: tei-server
template:
metadata:
labels:
app: tei-server
hf.co/model: Google--embeddinggemma-300m
hf.co/task: text-embeddings
spec:
containers:
- name: tei-container
image: ghcr.io/huggingface/text-embeddings-inference:cpu-latest
#image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-embeddings-inference-cpu.1-4:latest
resources:
requests:
cpu: "6"
memory: "24Gi"
limits:
cpu: "6"
memory: "24Gi"
env:
- name: MODEL_ID
value: google/embeddinggemma-300m
- name: NUM_SHARD
value: "1"
- name: PORT
value: "8080"
- name: HF_TOKEN
valueFrom:
secretKeyRef:
name: hf-secret
key: hf_api_token
volumeMounts:
- mountPath: /tmp
name: tmp
volumes:
- name: tmp
emptyDir: {}
nodeSelector:
#cloud.google.com/compute-class: "Performance"
cloud.google.com/machine-family: "c3"
Modell bereitstellen
Stellen Sie das Modell bereit, indem Sie das geänderte Manifest für CPU-Bereitstellungen anwenden.
kubectl apply -f Google-Cloud-Containers/examples/gke/tei-deployment/cpu-config
Deployments prüfen
kubectl get pods
Modelldienst überprüfen
kubectl get service tei-service
Es sollte der ausgeführte Diensttyp ClusterIP angezeigt werden.
Beispielausgabe:
student@cloudshell$ kubectl get service tei-service NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE tei-service ClusterIP 34.118.233.48 <none> 8080/TCP 10m
Die CLUSTER-IP für den Dienst wird als Endpunktadresse verwendet. Das Modelleinbettungsmodell kann über den URI http://34.118.233.48:8080/embed antworten. Sie wird später verwendet, wenn Sie das Modell in AlloyDB Omni registrieren.
Wir können es testen, indem wir es mit dem Befehl „kubectl port-forward“ verfügbar machen.
kubectl port-forward service/tei-service 8080:8080
Wenn Sie Cloud Shell verwenden, kann die Portweiterleitung in einer Cloud Shell-Sitzung ausgeführt werden. Wir benötigen eine weitere Sitzung, um sie zu testen.
Öffnen Sie oben über das Pluszeichen (+) einen weiteren Cloud Shell-Tab.
Führen Sie einen curl-Befehl in der neuen Shell-Sitzung aus.
curl http://localhost:8080/embed \
-X POST \
-d '{"inputs":"Test"}' \
-H 'Content-Type: application/json'
Es sollte ein Vektor-Array wie in der folgenden Beispielausgabe (redigiert) zurückgegeben werden:
curl http://localhost:8080/embed \
> -X POST \
> -d '{"inputs":"Test"}' \
> -H 'Content-Type: application/json'
[[-0.018975832,0.0071419072,0.06347208,0.022992613,0.014205903
...
-0.03677433,0.01636146,0.06731572]]
Wenn wir die Zahlen sehen, können wir bestätigen, dass wir das Modell erfolgreich getestet haben und es jetzt in unserem AlloyDB Omni registrieren können, damit es direkt über SQL verwendet werden kann.
6. Modell in AlloyDB Omni registrieren
Um zu testen, wie AlloyDB Omni mit dem bereitgestellten Modell funktioniert, müssen wir eine Datenbank erstellen und das Modell registrieren.
Datenbank erstellen
Erstellen Sie eine GCE-VM als Jump-Box, um von Ihrer Client-VM aus eine Verbindung zu AlloyDB Omni herzustellen und eine Datenbank zu erstellen.
Wir benötigen die Jumpbox, da der externe GKE-Load Balancer für Omni Ihnen über private IP-Adressierung Zugriff aus der VPC ermöglicht, aber keine Verbindung von außerhalb der VPC zulässt. Sie ist im Allgemeinen sicherer und Ihre Datenbankinstanz ist nicht dem Internet ausgesetzt. Bitte prüfen Sie das Diagramm auf Klarheit.
Führen Sie Folgendes aus, um eine VM in der Cloud Shell-Sitzung zu erstellen:
export ZONE=us-central1-a
gcloud compute instances create instance-1 \
--zone=$ZONE
So finden Sie die IP-Adresse des AlloyDB Omni-Endpunkts mit kubectl in Cloud Shell:
kubectl get dbclusters.alloydbomni.dbadmin.goog my-omni -n default
Notieren Sie sich den PRIMARYENDPOINT.
Hier ein Beispiel für eine Ausgabe:
student@cloudshell:~$ kubectl get dbclusters.alloydbomni.dbadmin.goog my-omni -n default NAME PRIMARYENDPOINT PRIMARYPHASE DBCLUSTERPHASE HAREADYSTATUS HAREADYREASON my-omni 10.131.0.33 Ready DBClusterReady student@cloudshell:~$
10.131.0.33 ist die IP-Adresse, die wir in unseren Beispielen verwenden, um eine Verbindung zur AlloyDB Omni-Instanz herzustellen.
Mit gcloud eine Verbindung zur VM herstellen:
gcloud compute ssh instance-1 --zone=$ZONE
Wenn Sie zur Generierung eines SSH-Schlüssels aufgefordert werden, folgen Sie der Anleitung. Weitere Informationen zur SSH-Verbindung finden Sie in der Dokumentation.
Installieren Sie in der SSH-Sitzung zur VM den PostgreSQL-Client:
sudo apt-get update
sudo apt-get install --yes postgresql-client
Exportieren Sie die AlloyDB Omni-Load-Balancer-IP-Variable mit dem folgenden Beispiel (ersetzen Sie IP durch die IP-Adresse Ihres Load-Balancers):
export INSTANCE_IP=10.131.0.33
Stellen Sie eine Verbindung zu AlloyDB Omni her. Das Passwort ist VeryStrongPassword, wie über den Hash in my-omni.yaml festgelegt:
psql "host=$INSTANCE_IP user=postgres sslmode=require"
Führen Sie in der eingerichteten psql-Sitzung Folgendes aus:
create database demo;
Beenden Sie die Sitzung und stellen Sie eine Verbindung zur Datenbankdemo her. Alternativ können Sie auch einfach \c demo in derselben Sitzung ausführen.
psql "host=$INSTANCE_IP user=postgres sslmode=require dbname=demo"
Transformationsfunktionen erstellen
Für Einbettungsmodelle von Drittanbietern müssen wir Transformationsfunktionen erstellen, die die Ein- und Ausgabe in das Format bringen, das vom Modell und unseren internen Funktionen erwartet wird. Diese Funktionen dienen als Übersetzer für die Formatkonvertierung zwischen verschiedenen Schnittstellen.
Hier ist die Transformationsfunktion, die die Eingabe verarbeitet:
-- Input Transform Function corresponding to the custom model endpoint
CREATE OR REPLACE FUNCTION tei_text_input_transform(model_id VARCHAR(100), input_text TEXT)
RETURNS JSON
LANGUAGE plpgsql
AS $$
DECLARE
transformed_input JSON;
model_qualified_name TEXT;
BEGIN
SELECT json_build_object('inputs', input_text, 'truncate', true)::JSON INTO transformed_input;
RETURN transformed_input;
END;
$$;
Führen Sie den bereitgestellten Code aus, während Sie mit der Demodatenbank verbunden sind, wie in der Beispielausgabe gezeigt:
demo=# -- Input Transform Function corresponding to the custom model endpoint
CREATE OR REPLACE FUNCTION tei_text_input_transform(model_id VARCHAR(100), input_text TEXT)
RETURNS JSON
LANGUAGE plpgsql
AS $$
DECLARE
transformed_input JSON;
model_qualified_name TEXT;
BEGIN
SELECT json_build_object('inputs', input_text, 'truncate', true)::JSON INTO transformed_input;
RETURN transformed_input;
END;
$$;
CREATE FUNCTION
demo=#
Und hier ist die Ausgabefunktion, die die Antwort des Modells in das Array mit reellen Zahlen umwandelt:
-- Output Transform Function corresponding to the custom model endpoint
CREATE OR REPLACE FUNCTION tei_text_output_transform(model_id VARCHAR(100), response_json JSON)
RETURNS REAL[]
LANGUAGE plpgsql
AS $$
DECLARE
transformed_output REAL[];
BEGIN
SELECT ARRAY(SELECT json_array_elements_text(response_json->0)) INTO transformed_output;
RETURN transformed_output;
END;
$$;
Führen Sie den Befehl in derselben Sitzung aus:
demo=# -- Output Transform Function corresponding to the custom model endpoint CREATE OR REPLACE FUNCTION tei_text_output_transform(model_id VARCHAR(100), response_json JSON) RETURNS REAL[] LANGUAGE plpgsql AS $$ DECLARE transformed_output REAL[]; BEGIN SELECT ARRAY(SELECT json_array_elements_text(response_json->0)) INTO transformed_output; RETURN transformed_output; END; $$; CREATE FUNCTION demo=#
Modell registrieren
Jetzt können wir das Modell in der Datenbank registrieren.
Hier ist der Prozeduraufruf zum Registrieren des Modells mit dem Namen embeddinggemma. Wir verwenden den Dienstnamen tei-service in unserem Parameter model_request_url, wenn wir das Modell registrieren. Das ist der interne Kubernetes-Clusterdienstname, der in die interne IP-Adresse im GKE-Cluster übersetzt wird:
CALL
google_ml.create_model(
model_id => 'embeddinggemma',
model_request_url => 'http://tei-service:8080/embed',
model_provider => 'custom',
model_type => 'text_embedding',
model_in_transform_fn => 'tei_text_input_transform',
model_out_transform_fn => 'tei_text_output_transform');
Führen Sie den bereitgestellten Code aus, während Sie mit der Demodatenbank verbunden sind:
demo=# CALL
google_ml.create_model(
model_id => 'embeddinggemma',
model_request_url => 'http://tei-service:8080/embed',
model_provider => 'custom',
model_type => 'text_embedding',
model_in_transform_fn => 'tei_text_input_transform',
model_out_transform_fn => 'tei_text_output_transform');
CALL
demo=#
Wir können das Registermodell mit der folgenden Testabfrage testen, die ein Array mit reellen Zahlen zurückgeben sollte.
select google_ml.embedding('embeddinggemma','What is AlloyDB Omni?');
Lassen Sie sich nicht von der langen Verzögerung überraschen, bevor Sie die Vektordaten zurückerhalten. Für diesen Test verwenden wir einen CPU-basierten Knotenpool zum Hosten des Einbettungsmodells. Auf Knoten mit GPU funktioniert das viel schneller.
7. Modell in AlloyDB Omni testen
Daten laden
Um zu testen, wie AlloyDB Omni mit dem bereitgestellten Modell funktioniert, müssen wir einige Daten laden. Ich habe dieselben Daten wie in einem der anderen Codelabs für die Vektorsuche in AlloyDB verwendet.
Eine Möglichkeit zum Laden der Daten besteht darin, das Google Cloud SDK und die PostgreSQL-Clientsoftware zu verwenden. Wir können dieselbe Client-VM verwenden. Das Google Cloud SDK sollte dort bereits installiert sein, wenn Sie die Standardwerte für das VM-Image verwendet haben. Wenn Sie ein benutzerdefiniertes Bild ohne Google SDK verwendet haben, können Sie es gemäß der Dokumentation hinzufügen.
Exportieren Sie die IP-Adresse des AlloyDB Omni-Load-Balancers wie im folgenden Beispiel (ersetzen Sie IP durch die IP-Adresse Ihres Load-Balancers):
export INSTANCE_IP=10.131.0.33
Stellen Sie eine Verbindung zur Datenbank her und aktivieren Sie die pgvector-Erweiterung.
psql "host=$INSTANCE_IP user=postgres sslmode=require dbname=demo"
In der psql-Sitzung:
CREATE EXTENSION IF NOT EXISTS vector;
Beenden Sie die psql-Sitzung und führen Sie in der Befehlszeilensitzung Befehle aus, um die Daten in die Demodatenbank zu laden.
Erstellen Sie die Tabellen. Mit dem folgenden Befehl wird die Datei „cymbal_demo_schema.sql“ abgerufen und der SQL-Code mit allen Tabellendefinitionen in der Demodatenbank ausgeführt:
gcloud storage cat gs://cloud-training/gcc/gcc-tech-004/cymbal_demo_schema.sql |psql "host=$INSTANCE_IP user=postgres dbname=demo"
Erwartete Konsolenausgabe:
student@cloudshell:~$ gcloud storage cat gs://cloud-training/gcc/gcc-tech-004/cymbal_demo_schema.sql |psql "host=$INSTANCE_IP user=postgres dbname=demo" Password for user postgres: 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@cloudshell:~$
Hier ist die Liste der erstellten Tabellen:
psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "\dt+"
Ausgabe:
student@cloudshell:~$ psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "\dt+"
Password for user postgres:
List of relations
Schema | Name | Type | Owner | Persistence | Access method | Size | Description
--------+------------------+-------+----------+-------------+---------------+------------+-------------
public | cymbal_embedding | table | postgres | permanent | heap | 8192 bytes |
public | cymbal_inventory | table | postgres | permanent | heap | 8192 bytes |
public | cymbal_products | table | postgres | permanent | heap | 8192 bytes |
public | cymbal_stores | table | postgres | permanent | heap | 8192 bytes |
(4 rows)
student@cloudshell:~$
Laden Sie Daten in die Tabelle cymbal_products:
gcloud storage cat gs://cloud-training/gcc/gcc-tech-004/cymbal_products.csv |psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "\copy cymbal_products from stdin csv header"
Erwartete Konsolenausgabe:
student@cloudshell:~$ gcloud storage cat gs://cloud-training/gcc/gcc-tech-004/cymbal_products.csv |psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "\copy cymbal_products from stdin csv header" COPY 941 student@cloudshell:~$
Hier sehen Sie ein Beispiel für einige Zeilen aus der Tabelle cymbal_products.
psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "SELECT uniq_id,left(product_name,30),left(product_description,50),sale_price FROM cymbal_products limit 3"
Ausgabe:
student@cloudshell:~$ psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "SELECT uniq_id,left(product_name,30),left(product_description,50),sale_price FROM cymbal_products limit 3"
Password for user postgres:
uniq_id | left | left | sale_price
----------------------------------+--------------------------------+----------------------------------------------------+------------
a73d5f754f225ecb9fdc64232a57bc37 | Laundry Tub Strainer Cup | Laundry tub strainer cup Chrome For 1-.50, drain | 11.74
41b8993891aa7d39352f092ace8f3a86 | LED Starry Star Night Light La | LED Starry Star Night Light Laser Projector 3D Oc | 46.97
ed4a5c1b02990a1bebec908d416fe801 | Surya Horizon HRZ-1060 Area Ru | The 100% polypropylene construction of the Surya | 77.4
(3 rows)
student@cloudshell:~$
Laden Sie Daten in die Tabelle cymbal_inventory:
gcloud storage cat gs://cloud-training/gcc/gcc-tech-004/cymbal_inventory.csv |psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "\copy cymbal_inventory from stdin csv header"
Erwartete Konsolenausgabe:
student@cloudshell:~$ gcloud storage cat gs://cloud-training/gcc/gcc-tech-004/cymbal_inventory.csv |psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "\copy cymbal_inventory from stdin csv header" Password for user postgres: COPY 263861 student@cloudshell:~$
Hier sehen Sie ein Beispiel für einige Zeilen aus der Tabelle cymbal_inventory.
psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "SELECT * FROM cymbal_inventory LIMIT 3"
Ausgabe:
student@cloudshell:~$ psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "SELECT * FROM cymbal_inventory LIMIT 3"
Password for user postgres:
store_id | uniq_id | inventory
----------+----------------------------------+-----------
1583 | adc4964a6138d1148b1d98c557546695 | 5
1490 | adc4964a6138d1148b1d98c557546695 | 4
1492 | adc4964a6138d1148b1d98c557546695 | 3
(3 rows)
student@cloudshell:~$
Laden Sie Daten in die Tabelle cymbal_stores:
gcloud storage cat gs://cloud-training/gcc/gcc-tech-004/cymbal_stores.csv |psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "\copy cymbal_stores from stdin csv header"
Erwartete Konsolenausgabe:
student@cloudshell:~$ gcloud storage cat gs://cloud-training/gcc/gcc-tech-004/cymbal_stores.csv |psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "\copy cymbal_stores from stdin csv header" Password for user postgres: COPY 4654 student@cloudshell:~$
Hier sehen Sie ein Beispiel für einige Zeilen aus der Tabelle cymbal_stores.
psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "SELECT store_id, name, zip_code FROM cymbal_stores limit 3"
Ausgabe:
student@cloudshell:~$ psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "SELECT store_id, name, zip_code FROM cymbal_stores limit 3"
Password for user postgres:
store_id | name | zip_code
----------+-------------------+----------
1990 | Mayaguez Store | 680
2267 | Ware Supercenter | 1082
4359 | Ponce Supercenter | 780
(3 rows)
student@cloudshell:~$
Einbettungen erstellen
Stellen Sie mit psql eine Verbindung zur Demodatenbank her und erstellen Sie Einbettungen für die Produkte in der Tabelle „cymbal_products“ auf Grundlage der Produktbeschreibungen.
Stellen Sie eine Verbindung zur Demodatenbank her:
psql "host=$INSTANCE_IP user=postgres sslmode=require dbname=demo"
Wir verwenden eine „cymbal_embedding“-Tabelle mit Spalteneinbettung zum Speichern unserer Einbettungen und die Produktbeschreibung als Texteingabe für die Funktion.
Aktivieren Sie das Timing für Ihre Abfragen, um sie später mit Remote-Modellen zu vergleichen:
\timing
Führen Sie die Abfrage aus, um die Einbettungen zu erstellen:
INSERT INTO cymbal_embedding(uniq_id,embedding) SELECT uniq_id, google_ml.embedding('embeddinggemma',product_description)::vector FROM cymbal_products;
Erwartete Konsolenausgabe:
demo=# INSERT INTO cymbal_embedding(uniq_id,embedding) SELECT uniq_id, google_ml.embedding('embeddinggemma',product_description)::vector FROM cymbal_products;
INSERT 0 941
Time: 497878.136 ms (08:17.878)
demo=#
In diesem Beispiel hat das Erstellen von Einbettungen etwa 8 Minuten gedauert. Das ist bei CPU-basierten Knotenpools normal. Bei einem Pool mit GPU-Beschleunigern kann es je nach GPU-Typ deutlich schneller gehen.
Testabfragen ausführen
Stellen Sie mit psql eine Verbindung zur Demodatenbank her und aktivieren Sie die Zeitmessung, um die Ausführungszeit für unsere Abfragen zu messen, wie wir es beim Erstellen von Einbettungen getan haben.
Wir suchen die fünf besten Produkte, die einer Anfrage wie „Welche Obstbäume wachsen hier gut?“ entsprechen, und verwenden die Kosinus-Distanz als Algorithmus für die Vektorsuche.
Führen Sie in der psql-Sitzung Folgendes aus:
SELECT
cp.product_name,
left(cp.product_description,80) as description,
cp.sale_price,
cs.zip_code,
(ce.embedding <=> google_ml.embedding('embeddinggemma','What kind of fruit trees grow well here?')::vector) as distance
FROM
cymbal_products cp
JOIN cymbal_embedding ce on
ce.uniq_id=cp.uniq_id
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 5;
Erwartete Konsolenausgabe:
demo=# SELECT
cp.product_name,
left(cp.product_description,80) as description,
cp.sale_price,
cs.zip_code,
(ce.embedding <=> google_ml.embedding('embeddinggemma','What kind of fruit trees grow well here?')::vector) as distance
FROM
cymbal_products cp
JOIN cymbal_embedding ce on
ce.uniq_id=cp.uniq_id
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 5;
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.5210549378080666
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.5639421771781971
Toyon | This is a beautiful toyon tree that can grow to be over 20 feet tall. It is an e | 10.00 | 93230 | 0.5670010914504852
Rose Bush | This is a beautiful rose bush that will produce fragrant roses. It is a perennia | 50.00 | 93230 | 0.5731542622882957
California Peppertree | This is a beautiful peppertree that can grow to be over 30 feet tall. It is an e | 25.00 | 93230 | 0.5750934653011995
(5 rows)
Time: 83.610 ms
demo=#
Die Abfrage wurde in 83 ms ausgeführt und hat eine Liste von Bäumen aus der Tabelle „cymbal_products“ zurückgegeben, die der Anfrage entsprechen und für die im Geschäft mit der Nummer 1583 Inventar verfügbar ist.
ANN-Index erstellen
Bei einem kleinen Datensatz ist es einfach, die genaue Suche zu verwenden, bei der alle Einbettungen gescannt werden. Wenn die Daten jedoch wachsen, steigen auch die Lade- und Reaktionszeiten. Sie können die Leistung verbessern, indem Sie Indizes für Ihre Einbettungsdaten erstellen. Hier sehen Sie ein Beispiel dafür, wie Sie das mit dem Google ScaNN-Index für Vektordaten tun können.
Stellen Sie die Verbindung zur Demodatenbank wieder her, wenn sie unterbrochen wurde:
psql "host=$INSTANCE_IP user=postgres sslmode=require dbname=demo"
Aktivieren Sie die Erweiterung „alloydb_scann“:
CREATE EXTENSION IF NOT EXISTS alloydb_scann;
Index erstellen:
CREATE INDEX cymbal_embedding_scann ON cymbal_embedding USING scann (embedding cosine);
Führen Sie dieselbe Abfrage wie zuvor aus und vergleichen Sie die Ergebnisse:
demo=# SELECT
cp.product_name,
left(cp.product_description,80) as description,
cp.sale_price,
cs.zip_code,
(ce.embedding <=> google_ml.embedding('embeddinggemma','What kind of fruit trees grow well here?')::vector) as distance
FROM
cymbal_products cp
JOIN cymbal_embedding ce on
ce.uniq_id=cp.uniq_id
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 5;
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.5210549378080666
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.5639421771781971
Toyon | This is a beautiful toyon tree that can grow to be over 20 feet tall. It is an e | 10.00 | 93230 | 0.5670010914504852
Rose Bush | This is a beautiful rose bush that will produce fragrant roses. It is a perennia | 50.00 | 93230 | 0.5731542622882957
California Peppertree | This is a beautiful peppertree that can grow to be over 30 feet tall. It is an e | 25.00 | 93230 | 0.5750934653011995
(5 rows)
Time: 64.783 ms
Die Ausführungszeit der Abfrage hat sich leicht verkürzt. Bei größeren Datasets wäre diese Verbesserung deutlicher zu sehen. Die Ergebnisse sind sehr ähnlich und wir haben die gleichen fünf wichtigsten Bäume im Ergebnis erhalten.
Probieren Sie andere Anfragen aus und lesen Sie in der Dokumentation mehr über die Auswahl von Vektorindexen.
AlloyDB Omni bietet noch mehr Funktionen und Labs.
8. Umgebung bereinigen
Jetzt können wir unseren GKE-Cluster mit AlloyDB Omni und einem KI-Modell löschen.
GKE-Cluster löschen
Führen Sie in Cloud Shell Folgendes aus:
export PROJECT_ID=$(gcloud config get project)
export LOCATION=us-central1
export CLUSTER_NAME=alloydb-ai-gke
gcloud container clusters delete ${CLUSTER_NAME} \
--project=${PROJECT_ID} \
--region=${LOCATION}
Erwartete Konsolenausgabe:
student@cloudshell:~$ gcloud container clusters delete ${CLUSTER_NAME} \
> --project=${PROJECT_ID} \
> --region=${LOCATION}
The following clusters will be deleted.
- [alloydb-ai-gke] in [us-central1]
Do you want to continue (Y/n)? Y
Deleting cluster alloydb-ai-gke...done.
Deleted
VM löschen
Führen Sie in Cloud Shell Folgendes aus:
export PROJECT_ID=$(gcloud config get project)
export ZONE=us-central1-a
gcloud compute instances delete instance-1 \
--project=${PROJECT_ID} \
--zone=${ZONE}
Erwartete Konsolenausgabe:
student@cloudshell:~$ export PROJECT_ID=$(gcloud config get project)
export ZONE=us-central1-a
gcloud compute instances delete instance-1 \
--project=${PROJECT_ID} \
--zone=${ZONE}
Your active configuration is: [cloudshell-5399]
The following instances will be deleted. Any attached disks configured to be auto-deleted will be deleted unless they are attached to any other instances or the `--keep-disks` flag is given and specifies them for keeping. Deleting a disk
is irreversible and any data on the disk will be lost.
- [instance-1] in [us-central1-a]
Do you want to continue (Y/n)? Y
Deleted
Wenn Sie für dieses Codelab ein neues Projekt erstellt haben, können Sie stattdessen das gesamte Projekt löschen: https://console.cloud.google.com/cloud-resource-manager
9. Glückwunsch
Herzlichen Glückwunsch zum Abschluss des Codelabs.
Behandelte Themen
- AlloyDB Omni in einem Google Kubernetes-Cluster bereitstellen
- Verbindung zu AlloyDB Omni herstellen
- Daten in AlloyDB Omni laden
- Offenes Embedding-Modell in GKE bereitstellen
- Einbettungsmodell in AlloyDB Omni registrieren
- Einbettungen für die semantische Suche generieren
- Generierte Einbettungen für die semantische Suche in AlloyDB Omni verwenden
- Vektorindexe in AlloyDB erstellen und verwenden
Weitere Informationen zum Arbeiten mit KI in AlloyDB Omni finden Sie in der Dokumentation.
10. Umfrage
Ausgabe: