Kubernetes पर AlloyDB Omni और EmbeddingGemma.

1. परिचय

इस कोडलैब में, आपको GKE पर AlloyDB Omni को डिप्लॉय करने और उसे उसी Kubernetes क्लस्टर में डिप्लॉय किए गए ओपन एम्बेडिंग मॉडल के साथ इस्तेमाल करने का तरीका बताया जाएगा. डेटाबेस इंस्टेंस के बगल में, एक ही GKE क्लस्टर में मॉडल को डिप्लॉय करने से, तीसरे पक्ष की सेवाओं पर निर्भरता कम हो जाती है और इंतज़ार का समय भी कम हो जाता है. इसके अलावा, स्थानीय तौर पर डिप्लॉयमेंट की ज़रूरत तब पड़ सकती है, जब सुरक्षा और अनुपालन से जुड़ी टीम ने यह तय किया हो कि डेटा को संगठन से बाहर नहीं जाना चाहिए और तीसरे पक्ष की सेवाओं का इस्तेमाल करने की अनुमति नहीं है.

ज़रूरी शर्तें

Google Cloud और Console की बुनियादी जानकारी
Kubernetes और GKE की बुनियादी जानकारी
कमांड लाइन इंटरफ़ेस और Cloud Shell में बुनियादी कौशल

आपको क्या सीखने को मिलेगा

Google Kubernetes क्लस्टर पर AlloyDB Omni को डिप्लॉय करने का तरीका
AlloyDB Omni से कनेक्ट करने का तरीका
AlloyDB Omni में डेटा लोड करने का तरीका
ओपन एम्बेडिंग मॉडल को GKE पर डिप्लॉय करने का तरीका
AlloyDB Omni में एम्बेडिंग मॉडल को रजिस्टर करने का तरीका
सिमेंटिक सर्च के लिए एम्बेडिंग जनरेट करने का तरीका
AlloyDB Omni में सिमेंटिक सर्च के लिए, जनरेट की गई एम्बेडिंग का इस्तेमाल करने का तरीका
AlloyDB में वेक्टर इंडेक्स बनाने और उनका इस्तेमाल करने का तरीका

आपको इन चीज़ों की ज़रूरत होगी

Google Cloud खाता और Google Cloud प्रोजेक्ट
Google Cloud Console और Cloud Shell के साथ काम करने वाला वेब ब्राउज़र, जैसे कि Chrome

2. सेटअप और ज़रूरी शर्तें

प्रोजेक्ट सेटअप करना

Google Cloud Console में साइन इन करें. अगर आपके पास पहले से कोई Gmail या Google Workspace खाता नहीं है, तो आपको एक खाता बनाना होगा.

ऑफ़िस या स्कूल वाले खाते के बजाय, निजी खाते का इस्तेमाल करें.

कोई नया प्रोजेक्ट बनाएं या किसी मौजूदा प्रोजेक्ट का फिर से इस्तेमाल करें. Google Cloud Console में नया प्रोजेक्ट बनाने के लिए, हेडर में मौजूद 'कोई प्रोजेक्ट चुनें' बटन पर क्लिक करें. इससे एक पॉप-अप विंडो खुलेगी.

'कोई प्रोजेक्ट चुनें' विंडो में, 'नया प्रोजेक्ट' बटन दबाएं. इससे नए प्रोजेक्ट के लिए एक डायलॉग बॉक्स खुलेगा.

डायलॉग बॉक्स में, अपने हिसाब से प्रोजेक्ट का नाम डालें और जगह चुनें.

प्रोजेक्ट का नाम, इस प्रोजेक्ट में हिस्सा लेने वाले लोगों के लिए डिसप्ले नेम होता है. प्रोजेक्ट के नाम का इस्तेमाल Google API नहीं करते हैं. इसे कभी भी बदला जा सकता है.
प्रोजेक्ट आईडी, सभी Google Cloud प्रोजेक्ट के लिए यूनीक होता है. साथ ही, इसे बदला नहीं जा सकता. Google Cloud Console, यूनीक आईडी अपने-आप जनरेट करता है. हालांकि, इसे अपनी पसंद के मुताबिक बनाया जा सकता है. अगर आपको जनरेट किया गया आईडी पसंद नहीं है, तो कोई दूसरा आईडी जनरेट करें. इसके अलावा, अपने हिसाब से कोई आईडी डालें और देखें कि वह उपलब्ध है या नहीं. ज़्यादातर कोडलैब में, आपको अपने प्रोजेक्ट आईडी का रेफ़रंस देना होगा. इसे आम तौर पर, PROJECT_ID प्लेसहोल्डर से पहचाना जाता है.
आपकी जानकारी के लिए बता दें कि एक तीसरी वैल्यू भी होती है, जिसे प्रोजेक्ट नंबर कहते हैं. इसका इस्तेमाल कुछ एपीआई करते हैं. इन तीनों वैल्यू के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.

बिलिंग चालू करें

निजी बिलिंग खाता सेट अप करना

अगर आपने Google Cloud क्रेडिट का इस्तेमाल करके बिलिंग सेट अप की है, तो इस चरण को छोड़ दें.

निजी बिलिंग खाता सेट अप करने के लिए, Cloud Console में बिलिंग की सुविधा चालू करने के लिए यहां जाएं.

ध्यान दें:

इस लैब को पूरा करने में, क्लाउड संसाधनों पर 3 डॉलर से कम खर्च आना चाहिए.
ज़्यादा शुल्क से बचने के लिए, इस लैब के आखिर में दिए गए निर्देशों का पालन करके संसाधनों को मिटाया जा सकता है.
नए उपयोगकर्ता, 300 डॉलर के मुफ़्त क्रेडिट का इस्तेमाल कर सकते हैं.

Cloud Shell शुरू करें

Google Cloud को अपने लैपटॉप से रिमोटली ऐक्सेस किया जा सकता है. हालांकि, इस कोडलैब में Google Cloud Shell का इस्तेमाल किया जाएगा. यह क्लाउड में चलने वाला कमांड लाइन एनवायरमेंट है.

Google Cloud Console में, सबसे ऊपर दाएं कोने में मौजूद टूलबार पर, Cloud Shell आइकॉन पर क्लिक करें:

Cloud Shell चालू करें

इसके अलावा, G और फिर S दबाकर भी यह सुविधा ऐक्सेस की जा सकती है. अगर Google Cloud Console में हैं, तो इस क्रम को दबाने पर Cloud Shell चालू हो जाएगा. इसके अलावा, इस लिंक का इस्तेमाल करके भी Cloud Shell चालू किया जा सकता है.

इसे चालू करने और एनवायरमेंट से कनेक्ट करने में सिर्फ़ कुछ सेकंड लगेंगे. यह प्रोसेस पूरी होने के बाद, आपको कुछ ऐसा दिखेगा:

Google Cloud Shell टर्मिनल का स्क्रीनशॉट. इसमें दिखाया गया है कि एनवायरमेंट कनेक्ट हो गया है

इस वर्चुअल मशीन में, डेवलपमेंट के लिए ज़रूरी सभी टूल पहले से मौजूद हैं. यह 5 जीबी की होम डायरेक्ट्री उपलब्ध कराता है. साथ ही, यह Google Cloud पर काम करता है. इससे नेटवर्क की परफ़ॉर्मेंस और पुष्टि करने की प्रोसेस बेहतर होती है. इस कोडलैब में मौजूद सभी टास्क, ब्राउज़र में किए जा सकते हैं. आपको कुछ भी इंस्टॉल करने की ज़रूरत नहीं है.

3. शुरू करने से पहले

एपीआई चालू करना

आउटपुट:

कृपया ध्यान दें कि अगर आपने प्रमोशन वाला टियर इस्तेमाल नहीं किया है, तो चालू किए गए कुछ संसाधनों के लिए आपको शुल्क देना होगा. आम तौर पर, लैब पूरा होने पर सभी संसाधनों को बंद कर दिया जाता है. ऐसे में, सभी संसाधनों की लागत 5 डॉलर से ज़्यादा नहीं होती. हमारा सुझाव है कि आप बिलिंग की जानकारी देखें और पक्का करें कि यह आपके लिए सही है.

AlloyDB Omni और ओपन मॉडल डिप्लॉयमेंट के लिए, Google Kubernetes Engine (GKE) का इस्तेमाल करने के लिए, आपको अपने Google Cloud प्रोजेक्ट में उनके एपीआई चालू करने होंगे.

Cloud Shell में, पक्का करें कि आपका प्रोजेक्ट आईडी सेट अप हो:

PROJECT_ID=$(gcloud config get-value project)
echo $PROJECT_ID

अगर इसे क्लाउड शेल कॉन्फ़िगरेशन में तय नहीं किया गया है, तो इसे सेट अप करने के लिए यहां दिए गए कमांड इस्तेमाल करें

export PROJECT_ID=<your project>
gcloud config set project $PROJECT_ID

सभी ज़रूरी सेवाएं चालू करें:

gcloud services enable compute.googleapis.com
gcloud services enable container.googleapis.com

अनुमानित आउटपुट

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.

एपीआई के बारे में जानकारी

Kubernetes Engine API (container.googleapis.com) की मदद से, Google Kubernetes Engine (GKE) क्लस्टर बनाए और मैनेज किए जा सकते हैं. यह Google के इन्फ़्रास्ट्रक्चर का इस्तेमाल करके, कंटेनर वाले ऐप्लिकेशन को डिप्लॉय करने, मैनेज करने, और स्केल करने के लिए मैनेज किया गया एनवायरमेंट उपलब्ध कराता है.
Compute Engine API (compute.googleapis.com) की मदद से, वर्चुअल मशीनें (वीएम), परसिस्टेंट डिस्क, और नेटवर्क सेटिंग बनाई और मैनेज की जा सकती हैं. यह Infrastructure-as-a-Service (IaaS) की मुख्य सुविधाएं उपलब्ध कराता है. इनकी मदद से, अपने वर्कलोड चलाए जा सकते हैं. साथ ही, मैनेज की जाने वाली कई सेवाओं के लिए बुनियादी इंफ़्रास्ट्रक्चर को होस्ट किया जा सकता है.

4. GKE पर AlloyDB Omni डिप्लॉय करना

GKE पर AlloyDB Omni को डिप्लॉय करने के लिए, हमें AlloyDB Omni ऑपरेटर की ज़रूरी शर्तों में दी गई ज़रूरी शर्तों के मुताबिक, Kubernetes क्लस्टर तैयार करना होगा.

GKE क्लस्टर बनाना

हमें एक स्टैंडर्ड GKE क्लस्टर डिप्लॉय करना होगा. साथ ही, एक ऐसा पूल कॉन्फ़िगरेशन भी डिप्लॉय करना होगा जो AlloyDB Omni इंस्टेंस के साथ पॉड को डिप्लॉय करने के लिए काफ़ी हो. AlloyDB Omni के लिए, हमें कम से कम दो सीपीयू और 8 जीबी रैम की ज़रूरत होती है. साथ ही, ऑपरेटर और मॉनिटरिंग सेवाओं के कंटेनर के लिए कुछ जगह खाली होनी चाहिए. हम e2-standard-4 वीएम टाइप का इस्तेमाल करेंगे.

डिप्लॉयमेंट के लिए एनवायरमेंट वैरिएबल सेट अप करें.

export PROJECT_ID=$(gcloud config get project)
export LOCATION=us-central1
export CLUSTER_NAME=alloydb-ai-gke
export MACHINE_TYPE=e2-standard-4

इसके बाद, हम GKE स्टैंडर्ड क्लस्टर बनाने के लिए 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

कंसोल का अनुमानित आउटपुट:

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)$

क्लस्टर तैयार करना

हमें ज़रूरी कॉम्पोनेंट इंस्टॉल करने होंगे. जैसे, cert-manager सेवा - Kubernetes के लिए नेटिव सर्टिफ़िकेट मैनेजर. हम cert-manager को इंस्टॉल करने के लिए, दस्तावेज़ में दिया गया तरीका अपना सकते हैं

हम Kubernetes के कमांड-लाइन टूल, kubectl का इस्तेमाल करते हैं. यह Cloud Shell में डिफ़ॉल्ट रूप से पहले से ही इंस्टॉल होता है. इस यूटिलिटी का इस्तेमाल करने से पहले, हमें अपने क्लस्टर के लिए क्रेडेंशियल पाने होंगे.

gcloud container clusters get-credentials ${CLUSTER_NAME} --region=${LOCATION}

अब हम cert-manager को इंस्टॉल करने के लिए, kubectl का इस्तेमाल कर सकते हैं:

kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.19.2/cert-manager.yaml

अनुमानित कंसोल आउटपुट(बदला गया):

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 इंस्टॉल करना

AlloyDB Omni ऑपरेटर को हेल्म यूटिलिटी का इस्तेमाल करके इंस्टॉल किया जा सकता है.

AlloyDB Omni ऑपरेटर को इंस्टॉल करने के लिए, यह कमांड चलाएं:

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

अनुमानित कंसोल आउटपुट(बदला गया):

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:~$

AlloyDB Omni ऑपरेटर इंस्टॉल होने के बाद, हम अपने डेटाबेस क्लस्टर को डिप्लॉय कर सकते हैं.

यहां googleMLExtension पैरामीटर और इंटरनल (निजी) लोड बैलेंसर चालू करके, डिप्लॉयमेंट मेनिफ़ेस्ट का उदाहरण दिया गया है:

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

पासवर्ड के लिए सीक्रेट वैल्यू, पासवर्ड "VeryStrongPassword" का Base64 फ़ॉर्मैट है. पासवर्ड की वैल्यू को सेव करने के लिए, Google Secret Manager का इस्तेमाल करना ज़्यादा भरोसेमंद तरीका है. इसके बारे में ज़्यादा जानने के लिए, दस्तावेज़ पढ़ें.

मेनिफ़ेस्ट को my-omni.yaml के तौर पर सेव करें, ताकि इसे अगले चरण में लागू किया जा सके. अगर Cloud Shell में हैं, तो एडिटर का इस्तेमाल करके ऐसा किया जा सकता है. इसके लिए, टर्मिनल के सबसे ऊपर दाईं ओर मौजूद "एडिटर खोलें" बटन दबाएं.

फ़ाइल को my-omni.yaml नाम से सेव करने के बाद, "टर्मिनल खोलें" बटन दबाकर वापस टर्मिनल पर जाएं.

kubectl यूटिलिटी का इस्तेमाल करके, क्लस्टर पर my-omni.yaml मेनिफ़ेस्ट लागू करें:

kubectl apply -f my-omni.yaml

कंसोल का अनुमानित आउटपुट:

secret/db-pw-my-omni created
dbcluster.alloydbomni.dbadmin.goog/my-omni created

kubectl यूटिलिटी का इस्तेमाल करके, अपने my-omni क्लस्टर की स्थिति देखें:

kubectl get dbclusters.alloydbomni.dbadmin.goog my-omni -n default

डप्लॉयमेंट के दौरान क्लस्टर अलग-अलग फ़ेज़ से गुज़रता है. आखिर में, इसकी स्थिति DBClusterReady होनी चाहिए.

कंसोल का अनुमानित आउटपुट:

$ kubectl get dbclusters.alloydbomni.dbadmin.goog my-omni -n default
NAME      PRIMARYENDPOINT   PRIMARYPHASE   DBCLUSTERPHASE   HAREADYSTATUS   HAREADYREASON
my-omni   10.131.0.33        Ready          DBClusterReady

AlloyDB Omni से कनेक्ट करना

Kubernetes पॉड का इस्तेमाल करके कनेक्ट करना

क्लस्टर तैयार होने के बाद, हम AlloyDB Omni इंस्टेंस पॉड पर PostgreSQL क्लाइंट बाइनरी का इस्तेमाल कर सकते हैं. हम पॉड आईडी ढूंढते हैं. इसके बाद, kubectl का इस्तेमाल करके सीधे पॉड से कनेक्ट करते हैं और क्लाइंट सॉफ़्टवेयर चलाते हैं. my-omni.yaml मेनिफ़ेस्ट में kubernetes secret के ज़रिए सेट किया गया पासवर्ड VeryStrongPassword है:

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

कंसोल आउटपुट का सैंपल:

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. GKE पर एआई मॉडल डिप्लॉय करना

AlloyDB Omni के एआई इंटिग्रेशन को स्थानीय मॉडल के साथ टेस्ट करने के लिए, हमें क्लस्टर में एक मॉडल डिप्लॉय करना होगा. हम Google के EmbeddingGemma मॉडल का इस्तेमाल करेंगे.

मॉडल के लिए नोड पूल बनाना

मॉडल को चलाने के लिए, हमें अनुमान लगाने के लिए एक नोड पूल तैयार करना होगा. इसे सिर्फ़ सीपीयू पूल या जीपीयू ऐक्सलरेटर वाले पूल का इस्तेमाल करके चलाया जा सकता है. संसाधनों के लिए ज़्यादा एक साथ होने वाली प्रोसेस की वजह से, कुछ देशों/इलाकों में सिर्फ़ सीपीयू का इस्तेमाल करना ज़्यादा फ़ायदेमंद हो सकता है. हम अपने लैब में सीपीयू का इस्तेमाल करेंगे. हालांकि, परफ़ॉर्मेंस के हिसाब से सबसे अच्छा तरीका, ग्राफ़िक ऐक्सलरेटर वाला पूल है. इसमें L4 Nvidia ऐक्सलरेटर के साथ g2-standard-8 जैसे नोड कॉन्फ़िगरेशन का इस्तेमाल किया जाता है.

सीपीयू पर आधारित नोड पूल

e2-standard-32 नोड वाला नोड पूल बनाएं. हम संसाधनों को बचाने के लिए, सिर्फ़ एक नोड से डेटा पुल करेंगे.

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

अनुमानित आउटपुट

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 का टोकन पाना

इस लैब में, EmbeddingGemma मॉडल को डिप्लॉय करने के लिए, हम Hugging Face के साथ साझेदारी करते हैं. इसके लिए, हमें Hugging Face टोकन की ज़रूरत होती है.

अगर आपको पहले कभी टोकन नहीं मिला है, तो नया टोकन जनरेट करने के लिए, यहां दिया गया तरीका अपनाएं.

Hugging Face की साइट पर लॉग इन करें या साइन अप करें. इसके लिए, सबसे ऊपर दाएं कोने में मौजूद, Log In या Sign Up लिंक का इस्तेमाल करें.
अपनी प्रोफ़ाइल -> ऐक्सेस टोकन पर क्लिक करें
अपनी पहचान की पुष्टि करें
'नया टोकन बनाएं' पर क्लिक करें
अपने टोकन के लिए कोई नाम चुनें
टोकन के लिए कोई भूमिका चुनें - आपके पास कम से कम पढ़ने का अधिकार होना चाहिए
पेज पर सबसे नीचे मौजूद, टोकन बनाएं पर क्लिक करें
जनरेट किए गए टोकन को कॉपी करें और बाद में इस्तेमाल करने के लिए सेव करें

साथ ही, आपको Hugging Face पर EmbeddingGemma से जुड़ी फ़ाइलों और कॉन्टेंट को ऐक्सेस करने के लिए, https://huggingface.co/google/embeddinggemma-300m पेज पर जाकर शर्तें स्वीकार करनी होंगी

टोकन का इस्तेमाल करके, Kubernetes सीक्रेट बनाएं

क्लाउड शेल सेशन में, इस कमांड को चलाएं. HF_TOKEN की वैल्यू को अपने HF टोकन से बदलें.

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 -

डिप्लॉयमेंट मेनिफ़ेस्ट तैयार करना

मॉडल को डिप्लॉय करने के लिए, हमें डिप्लॉयमेंट मेनिफ़ेस्ट तैयार करना होगा.

हम Hugging Face के EmbeddingGemma मॉडल का इस्तेमाल कर रहे हैं. मॉडल कार्ड यहां देखा जा सकता है. मॉडल को डिप्लॉय करने के लिए, हम Hugging Face के निर्देशों और GitHub के डिप्लॉयमेंट पैकेज के आधार पर एक तरीका इस्तेमाल करेंगे.

GitHub से पैकेज का क्लोन बनाना

git clone https://github.com/huggingface/Google-Cloud-Containers

सीपीयू नोड पर, टीईआई (टेक्स्ट एम्बेडिंग इंटरफ़ेस) के लिए मेनिफ़ेस्ट में बदलाव करें. हमें कई पैरामीटर बदलने होंगे. जैसे, मॉडल, इमेज, सही संसाधन का बंटवारा. साथ ही, कॉन्फ़िगरेशन में Hugging Face टोकन सीक्रेट जोड़ना होगा.

किसी भी उपलब्ध एडिटर का इस्तेमाल करके, मेनिफ़ेस्ट में बदलाव करें

vi Google-Cloud-Containers/examples/gke/tei-deployment/cpu-config/deployment.yaml

यहां सीपीयू पर आधारित पूल पर डिप्लॉय करने के लिए, सही किया गया मेनिफ़ेस्ट दिया गया है.

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"

मॉडल डिप्लॉय करना

सीपीयू डिप्लॉयमेंट के लिए, बदले गए मेनिफ़ेस्ट को लागू करके मॉडल डिप्लॉय करें.

kubectl apply -f Google-Cloud-Containers/examples/gke/tei-deployment/cpu-config

डिप्लॉयमेंट की पुष्टि करना

kubectl get pods

मॉडल सेवा की पुष्टि करना

kubectl get service tei-service

इसमें चल रही सेवा का टाइप ClusterIP दिखना चाहिए

आउटपुट का उदाहरण:

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

हम सेवा के लिए CLUSTER-IP को एंडपॉइंट पते के तौर पर इस्तेमाल करेंगे. मॉडल एम्बेड करने की सुविधा, http://34.118.233.48:8080/embed यूआरआई के ज़रिए जवाब दे सकती है. इसका इस्तेमाल बाद में तब किया जाएगा, जब AlloyDB Omni में मॉडल रजिस्टर किया जाएगा.

हम इसे kubectl port-forward कमांड का इस्तेमाल करके, टेस्ट कर सकते हैं.

kubectl port-forward service/tei-service 8080:8080

अगर Cloud Shell का इस्तेमाल किया जा रहा है, तो पोर्ट फ़ॉरवर्डिंग एक Cloud Shell सेशन में चल सकती है. हमें इसे आज़माने के लिए, किसी दूसरे सेशन की ज़रूरत होगी.

सबसे ऊपर मौजूद "+" साइन का इस्तेमाल करके, Cloud Shell का कोई दूसरा टैब खोलें.

इसके बाद, नए शेल सेशन में curl कमांड चलाएं.

curl http://localhost:8080/embed \
    -X POST \
    -d '{"inputs":"Test"}' \
    -H 'Content-Type: application/json'

इसे इस तरह का वेक्टर कलेक्शन दिखाना चाहिए, जैसा कि यहां दिए गए सैंपल आउटपुट (बदला गया) में दिखाया गया है:

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]]

अगर हमें नंबर दिखते हैं, तो हम पुष्टि कर सकते हैं कि हमने मॉडल की जांच कर ली है. अब हम इसे AlloyDB Omni में रजिस्टर कर सकते हैं, ताकि इसे सीधे तौर पर SQL से इस्तेमाल किया जा सके.

6. AlloyDB Omni में मॉडल रजिस्टर करना

यह जांच करने के लिए कि हमारा AlloyDB Omni, डिप्लॉय किए गए मॉडल के साथ कैसे काम करता है, हमें एक डेटाबेस बनाना होगा और मॉडल को रजिस्टर करना होगा.

डेटाबेस बनाएं

अपने क्लाइंट वीएम से AlloyDB Omni से कनेक्ट करने के लिए, जंप बॉक्स के तौर पर GCE वीएम बनाएं. इसके बाद, एक डेटाबेस बनाएं.

हमें जंप बॉक्स की ज़रूरत है, क्योंकि Omni के लिए GKE का बाहरी लोड बैलेंसर, निजी आईपी पते का इस्तेमाल करके वीपीसी से ऐक्सेस करने की सुविधा देता है. हालांकि, यह आपको वीपीसी के बाहर से कनेक्ट करने की अनुमति नहीं देता. यह आम तौर पर ज़्यादा सुरक्षित होता है और आपके डेटाबेस इंस्टेंस को इंटरनेट पर नहीं दिखाता है. कृपया साफ़ तौर पर समझने के लिए, डायग्राम देखें.

Cloud Shell सेशन में वीएम बनाने के लिए, यह कमांड चलाएं:

export ZONE=us-central1-a
gcloud compute instances create instance-1 \
    --zone=$ZONE

Cloud Shell में kubectl का इस्तेमाल करके, AlloyDB Omni एंडपॉइंट का आईपी पता ढूंढें:

kubectl get dbclusters.alloydbomni.dbadmin.goog my-omni -n default

PRIMARYENDPOINT को लिख लें.

यहां आउटपुट का एक उदाहरण दिया गया है:

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 वह आईपी पता है जिसका इस्तेमाल हम अपने उदाहरणों में, AlloyDB Omni इंस्टेंस से कनेक्ट करने के लिए करेंगे.

gcloud का इस्तेमाल करके वीएम से कनेक्ट करें:

gcloud compute ssh instance-1 --zone=$ZONE

अगर एसएसएच कुंजी जनरेट करने के लिए कहा जाता है, तो निर्देशों का पालन करें. दस्तावेज़ में, एसएसएच कनेक्शन के बारे में ज़्यादा पढ़ें.

वीएम में ssh सेशन के दौरान, PostgreSQL क्लाइंट इंस्टॉल करें:

sudo apt-get update
sudo apt-get install --yes postgresql-client

यहां दिए गए उदाहरण का इस्तेमाल करके, AlloyDB Omni लोड बैलेंसर के आईपी वैरिएबल को एक्सपोर्ट करें. आईपी को अपने लोड बैलेंसर के आईपी से बदलें:

export INSTANCE_IP=10.131.0.33

AlloyDB Omni से कनेक्ट करें. पासवर्ड VeryStrongPassword है, जिसे my-omni.yaml में हैश के ज़रिए सेट किया गया है:

psql "host=$INSTANCE_IP user=postgres sslmode=require"

psql सेशन में यह कमांड चलाएं:

create database demo;

सेशन से बाहर निकलें और डेटाबेस डेमो से कनेक्ट करें. इसके अलावा, उसी सेशन में \c demo को चलाया जा सकता है

psql "host=$INSTANCE_IP user=postgres sslmode=require dbname=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;
$$;

डेमो डेटाबेस से कनेक्ट होने के दौरान, दिए गए कोड को एक्ज़ीक्यूट करें. यह कोड, सैंपल आउटपुट में दिखाया गया है:

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=#

यहां आउटपुट फ़ंक्शन दिया गया है, जो मॉडल से मिले जवाब को असली संख्याओं की कैटगरी में बदलता है:

-- 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;
$$;

उसे उसी सेशन में लागू करें:

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=#

मॉडल रजिस्टर करना

अब हम मॉडल को डेटाबेस में रजिस्टर कर सकते हैं.

यहां embeddinggemma नाम से मॉडल रजिस्टर करने के लिए, कॉल करने का तरीका बताया गया है. मॉडल को रजिस्टर करते समय, हम अपने model_request_url पैरामीटर में tei-service सेवा के नाम का इस्तेमाल करते हैं. यह इंटरनल Kubernetes क्लस्टर सेवा का नाम है. यह GKE क्लस्टर में इंटरनल आईपी में बदल जाता है:

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');

डेमो डेटाबेस से कनेक्ट होने पर, दिया गया कोड चलाएं:

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=#

हम रजिस्टर मॉडल को टेस्ट करने के लिए, इस टेस्ट क्वेरी का इस्तेमाल कर सकते हैं. इससे असली संख्याओं की एक अरे मिलनी चाहिए.

select google_ml.embedding('embeddinggemma','What is AlloyDB Omni?');

वेक्टर डेटा वापस मिलने में ज़्यादा समय लग सकता है. इसलिए, इसमें हैरानी की कोई बात नहीं है. इस टेस्ट के लिए, हम सीपीयू पर आधारित नोड पूल का इस्तेमाल करके एम्बेडिंग मॉडल को होस्ट करते हैं. यह मॉडल, जीपीयू वाले नोड पर ज़्यादा तेज़ी से काम करता है.

7. AlloyDB Omni में मॉडल को टेस्ट करना

डेटा लोड करें

यह जांच करने के लिए कि डिप्लॉय किया गया मॉडल, AlloyDB Omni के साथ कैसे काम करता है, हमें कुछ डेटा लोड करना होगा. मैंने AlloyDB में वेक्टर सर्च के लिए, वही डेटा इस्तेमाल किया है जो अन्य कोडलैब में से किसी एक में इस्तेमाल किया गया था.

डेटा लोड करने का एक तरीका यह है कि Google Cloud SDK और PostgreSQL क्लाइंट सॉफ़्टवेयर का इस्तेमाल किया जाए. हम उसी क्लाइंट वीएम का इस्तेमाल कर सकते हैं. अगर आपने वीएम इमेज के लिए डिफ़ॉल्ट सेटिंग का इस्तेमाल किया है, तो Google Cloud SDK पहले से ही इंस्टॉल होना चाहिए. हालांकि, अगर आपने Google SDK के बिना किसी कस्टम इमेज का इस्तेमाल किया है, तो दस्तावेज़ में दिए गए निर्देशों का पालन करके उसे जोड़ा जा सकता है.

AlloyDB Omni लोड बैलेंसर के आईपी को एक्सपोर्ट करें. इसके लिए, यहां दिया गया उदाहरण देखें. आईपी की जगह अपने लोड बैलेंसर का आईपी डालें:

export INSTANCE_IP=10.131.0.33

डेटाबेस से कनेक्ट करें और pgvector एक्सटेंशन चालू करें.

psql "host=$INSTANCE_IP user=postgres sslmode=require dbname=demo"

psql सेशन में:

CREATE EXTENSION IF NOT EXISTS vector;

psql सेशन से बाहर निकलें. इसके बाद, कमांड लाइन सेशन में डेमो डेटाबेस में डेटा लोड करने के लिए कमांड चलाएं.

टेबल बनाना. नीचे दी गई कमांड से, cymbal_demo_schema.sql फ़ाइल मिल जाएगी. साथ ही, यह डेमो डेटाबेस में सभी टेबल की परिभाषाओं के साथ SQL को एक्ज़ीक्यूट करेगी:

gcloud storage cat gs://cloud-training/gcc/gcc-tech-004/cymbal_demo_schema.sql |psql "host=$INSTANCE_IP user=postgres dbname=demo"

कंसोल का अनुमानित आउटपुट:

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:~$

यहां बनाई गई टेबल की सूची दी गई है:

psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "\dt+"

आउटपुट:

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:~$

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"

कंसोल का अनुमानित आउटपुट:

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:~$

यहां 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"

आउटपुट:

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:~$

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"

कंसोल का अनुमानित आउटपुट:

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:~$

यहां cymbal_inventory टेबल की कुछ लाइनों का सैंपल दिया गया है.

psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "SELECT * FROM cymbal_inventory LIMIT 3"

आउटपुट:

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:~$

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"

कंसोल का अनुमानित आउटपुट:

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:~$

यहां cymbal_stores टेबल की कुछ लाइनों का सैंपल दिया गया है.

psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "SELECT store_id, name, zip_code FROM cymbal_stores limit 3"

आउटपुट:

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:~$

एम्बेडिंग बनाना

psql का इस्तेमाल करके डेमो डेटाबेस से कनेक्ट करें. साथ ही, cymbal_products टेबल में बताए गए प्रॉडक्ट के लिए एम्बेडिंग बनाएं. ये एम्बेडिंग, प्रॉडक्ट के ब्यौरे के आधार पर बनाई जाएंगी.

डेमो डेटाबेस से कनेक्ट करें:

psql "host=$INSTANCE_IP user=postgres sslmode=require dbname=demo"

हम अपनी एम्बेडिंग को सेव करने के लिए, कॉलम एम्बेडिंग वाली cymbal_embedding टेबल का इस्तेमाल कर रहे हैं. साथ ही, हम फ़ंक्शन के लिए टेक्स्ट इनपुट के तौर पर प्रॉडक्ट के ब्यौरे का इस्तेमाल करते हैं.

अपनी क्वेरी के लिए टाइमिंग की सुविधा चालू करें, ताकि बाद में रिमोट मॉडल से तुलना की जा सके.:

\timing

एम्बेडिंग बनाने के लिए क्वेरी चलाएं:

INSERT INTO cymbal_embedding(uniq_id,embedding)  SELECT uniq_id, google_ml.embedding('embeddinggemma',product_description)::vector FROM cymbal_products;

कंसोल का अनुमानित आउटपुट:

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=#

इस उदाहरण में, बिल्डिंग एम्बेडिंग में करीब आठ मिनट लगे. सीपीयू पर आधारित नोड पूल के लिए, ऐसा होना सामान्य है. जीपीयू ऐक्सेलरेटर वाले पूल के लिए, यह जीपीयू के टाइप के हिसाब से काफ़ी तेज़ हो सकता है.

टेस्ट क्वेरी चलाना

psql का इस्तेमाल करके डेमो डेटाबेस से कनेक्ट करें. साथ ही, टाइमिंग की सुविधा चालू करें, ताकि हम अपनी क्वेरी के एक्ज़ीक्यूशन टाइम को मेज़र कर सकें. ऐसा ही हमने एम्बेडिंग बनाने के लिए किया था.

आइए, वेक्टर सर्च के लिए कोसाइन दूरी को एल्गोरिदम के तौर पर इस्तेमाल करके, "यहां किस तरह के फलों के पेड़ अच्छी तरह से उगते हैं?" जैसे अनुरोध से मेल खाने वाले टॉप 5 प्रॉडक्ट ढूंढें.

psql सेशन में यह कमांड चलाएं:

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;

कंसोल का अनुमानित आउटपुट:

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=#

क्वेरी को पूरा होने में 83 मि॰से॰ लगे. इसने cymbal_products टेबल से, अनुरोध से मेल खाने वाले ट्री की सूची दिखाई. साथ ही, इसमें स्टोर नंबर 1583 में उपलब्ध इन्वेंट्री भी दिखाई गई.

एएनएन इंडेक्स बनाना

जब हमारे पास सिर्फ़ छोटा डेटा सेट होता है, तब सभी एम्बेडिंग को स्कैन करके सटीक खोज का इस्तेमाल करना आसान होता है. हालांकि, जब डेटा बढ़ता है, तो लोड होने और जवाब मिलने में लगने वाला समय भी बढ़ जाता है. परफ़ॉर्मेंस को बेहतर बनाने के लिए, अपने एम्बेडिंग डेटा पर इंडेक्स बनाए जा सकते हैं. वेक्टर डेटा के लिए, Google ScaNN इंडेक्स का इस्तेमाल करके ऐसा करने का तरीका यहां बताया गया है.

अगर आपका कनेक्शन डेमो डेटाबेस से टूट गया है, तो उसे फिर से कनेक्ट करें:

psql "host=$INSTANCE_IP user=postgres sslmode=require dbname=demo"

alloydb_scann एक्सटेंशन चालू करें:

CREATE EXTENSION IF NOT EXISTS alloydb_scann;

इंडेक्स बनाएं:

CREATE INDEX cymbal_embedding_scann ON cymbal_embedding USING scann (embedding cosine);

पहले वाली क्वेरी को फिर से आज़माएं और नतीजों की तुलना करें:

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

क्वेरी को पूरा होने में लगने वाला समय थोड़ा कम हो गया है. बड़े डेटासेट के साथ, यह फ़ायदा ज़्यादा दिखेगा. नतीजे काफ़ी मिलते-जुलते हैं और हमें नतीजे में एक ही तरह के टॉप 5 ट्री मिले हैं..

अन्य क्वेरी आज़माएं. साथ ही, दस्तावेज़ में वेक्टर इंडेक्स चुनने के बारे में ज़्यादा पढ़ें.

साथ ही, यह न भूलें कि AlloyDB Omni में ज़्यादा सुविधाएं और लैब हैं.

AlloyDB Omni में कॉलम वाले इंजन की मदद से, ऐनलिटिकल क्वेरी को तेज़ी से प्रोसेस करना

8. एनवायरमेंट को साफ़ करना

अब हम AlloyDB Omni और एआई मॉडल की मदद से, अपने GKE क्लस्टर को मिटा सकते हैं

GKE क्लस्टर मिटाएं

Cloud Shell में यह कमांड चलाएं:

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}

कंसोल का अनुमानित आउटपुट:

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

वीएम मिटाएं

Cloud Shell में यह कमांड चलाएं:

export PROJECT_ID=$(gcloud config get project)
export ZONE=us-central1-a
gcloud compute instances delete instance-1 \
  --project=${PROJECT_ID} \
  --zone=${ZONE}

कंसोल का अनुमानित आउटपुट:

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

अगर आपने इस कोडलैब के लिए कोई नया प्रोजेक्ट बनाया है, तो पूरे प्रोजेक्ट को मिटाया जा सकता है: https://console.cloud.google.com/cloud-resource-manager

9. बधाई हो

कोडलैब पूरा करने के लिए बधाई.

हमने क्या-क्या बताया

Google Kubernetes क्लस्टर पर AlloyDB Omni को डिप्लॉय करने का तरीका
AlloyDB Omni से कनेक्ट करने का तरीका
AlloyDB Omni में डेटा लोड करने का तरीका
ओपन एम्बेडिंग मॉडल को GKE पर डिप्लॉय करने का तरीका
AlloyDB Omni में एम्बेडिंग मॉडल को रजिस्टर करने का तरीका
सिमेंटिक सर्च के लिए एम्बेडिंग जनरेट करने का तरीका
AlloyDB Omni में सिमेंटिक सर्च के लिए, जनरेट की गई एम्बेडिंग का इस्तेमाल करने का तरीका
AlloyDB में वेक्टर इंडेक्स बनाने और उनका इस्तेमाल करने का तरीका

AlloyDB Omni में एआई का इस्तेमाल करने के बारे में ज़्यादा जानने के लिए, दस्तावेज़ पढ़ें.

10. सर्वे

आउटपुट:

इस ट्यूटोरियल का इस्तेमाल कैसे किया जाएगा?

सिर्फ़ इसे पढ़ें

इसे पढ़ें और एक्सरसाइज़ पूरी करें