AlloyDB में हाइब्रिड सर्च का इस्तेमाल शुरू करना

1. परिचय

इस कोडलैब में, आपको AlloyDB में हाइब्रिड सर्च करने का तरीका बताया जाएगा. इसके लिए, रैंकिंग अपडेट करने के तरीके (आरयूएम) एक्सटेंशन और स्केलेबल नियरेस्ट नेबर (एसकैन) इंडेक्स का इस्तेमाल किया जाता है. यह लैब, AlloyDB की एआई सुविधाओं के लिए उपलब्ध लैब के कलेक्शन का हिस्सा है. दस्तावेज़ में AlloyDB AI पेज पर जाकर, इस बारे में ज़्यादा पढ़ें.

ज़रूरी शर्तें

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

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

AlloyDB क्लस्टर और प्राइमरी इंस्टेंस को डिप्लॉय करने का तरीका
Google Compute Engine वीएम से AlloyDB से कनेक्ट करने का तरीका
डेटाबेस बनाने और AlloyDB AI को चालू करने का तरीका
डेटाबेस में डेटा लोड करने का तरीका
AlloyDB Studio का इस्तेमाल कैसे करें
Vertex AI की मदद से एम्बेडिंग जनरेट करना
वेक्टर सर्च को बेहतर बनाने के लिए, ScaNN वेक्टर इंडेक्स बनाने का तरीका
फ़ुल-टेक्स्ट सर्च के लिए, RUM एक्सटेंशन को चालू और इस्तेमाल करने का तरीका
फ़ुल-टेक्स्ट सर्च, वेक्टर सर्च, और रेसिप्रोकल रैंक फ़्यूज़न (आरआरएफ़) को मिलाकर हाइब्रिड सर्च करना

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

Google Cloud खाता और Google Cloud प्रोजेक्ट
कोई वेब ब्राउज़र, जैसे कि Chrome

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

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

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

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

Google Cloud प्रोजेक्ट बनाना

Google Cloud Console में, प्रोजेक्ट चुनने वाले पेज पर, Google Cloud प्रोजेक्ट चुनें या बनाएं.
पक्का करें कि आपके Cloud प्रोजेक्ट के लिए बिलिंग चालू हो. किसी प्रोजेक्ट के लिए बिलिंग चालू है या नहीं, यह देखने का तरीका जानें.

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

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

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

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

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

ध्यान दें:

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

Cloud Shell शुरू करें

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

Cloud Shell, Google Cloud में चलने वाला एक कमांड-लाइन एनवायरमेंट है. इसमें ज़रूरी टूल पहले से लोड होते हैं.

Google Cloud कंसोल में सबसे ऊपर मौजूद, Cloud Shell चालू करें पर क्लिक करें.
Cloud Shell से कनेक्ट होने के बाद, अपने क्रेडेंशियल की पुष्टि करें:
```
gcloud auth list
```
पुष्टि करें कि आपका प्रोजेक्ट कॉन्फ़िगर किया गया है:
```
gcloud config get project
```
अगर आपका प्रोजेक्ट उम्मीद के मुताबिक सेट नहीं है, तो इसे सेट करें:
```
export PROJECT_ID=<YOUR_PROJECT_ID>
gcloud config set project $PROJECT_ID
```

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

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

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

आउटपुट:

AlloyDB, Compute Engine, नेटवर्किंग सेवाएं, और Vertex AI का इस्तेमाल करने के लिए, आपको अपने Google Cloud प्रोजेक्ट में इनसे जुड़े एपीआई चालू करने होंगे.

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

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

gcloud config set project [YOUR-PROJECT-ID]

PROJECT_ID एनवायरमेंट वैरिएबल सेट करें:

PROJECT_ID=$(gcloud config get-value project)

ज़रूरी एपीआई चालू करें:

gcloud services enable alloydb.googleapis.com \
                       compute.googleapis.com \
                       cloudresourcemanager.googleapis.com \
                       servicenetworking.googleapis.com \
                       aiplatform.googleapis.com

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

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.

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

AlloyDB API (alloydb.googleapis.com) की मदद से, AlloyDB for PostgreSQL क्लस्टर बनाए, मैनेज किए जा सकते हैं, और उन्हें स्केल किया जा सकता है. यह पूरी तरह से मैनेज की गई, PostgreSQL के साथ काम करने वाली डेटाबेस सेवा है. इसे एंटरप्राइज़ के लेन-देन और ऐनलिटिकल वर्कलोड की ज़रूरतों को पूरा करने के लिए डिज़ाइन किया गया है.
Compute Engine API (compute.googleapis.com) की मदद से, वर्चुअल मशीनें (वीएम), परसिस्टेंट डिस्क, और नेटवर्क सेटिंग बनाई और मैनेज की जा सकती हैं. यह मुख्य Infrastructure-as-a-Service (IaaS) फ़ाउंडेशन उपलब्ध कराता है. इसकी मदद से, अपने वर्कलोड चलाए जा सकते हैं. साथ ही, मैनेज की जाने वाली कई सेवाओं के लिए बुनियादी इंफ़्रास्ट्रक्चर को होस्ट किया जा सकता है.
Cloud Resource Manager API (cloudresourcemanager.googleapis.com) की मदद से, Google Cloud प्रोजेक्ट के मेटाडेटा और कॉन्फ़िगरेशन को प्रोग्राम के हिसाब से मैनेज किया जा सकता है. इससे आपको संसाधनों को व्यवस्थित करने, पहचान और ऐक्सेस मैनेजमेंट (IAM) नीतियों को मैनेज करने, और प्रोजेक्ट के क्रम में अनुमतियों की पुष्टि करने में मदद मिलती है.
Service Networking API (servicenetworking.googleapis.com) की मदद से, अपने वर्चुअल प्राइवेट क्लाउड (वीपीसी) नेटवर्क और Google की मैनेज की गई सेवाओं के बीच निजी कनेक्टिविटी को अपने-आप सेट अप किया जा सकता है. AlloyDB जैसी सेवाओं के लिए, प्राइवेट आईपी ऐक्सेस सेट अप करना ज़रूरी है. इससे वे आपके अन्य संसाधनों के साथ सुरक्षित तरीके से कम्यूनिकेट कर पाती हैं.
Vertex AI API (aiplatform.googleapis.com) की मदद से, आपके ऐप्लिकेशन मशीन लर्निंग मॉडल बना सकते हैं, उन्हें डिप्लॉय कर सकते हैं, और बड़े पैमाने पर उपलब्ध करा सकते हैं. यह Google Cloud की सभी एआई सेवाओं के लिए, एक जैसा इंटरफ़ेस उपलब्ध कराता है. इसमें जनरेटिव एआई मॉडल (जैसे, Gemini) का ऐक्सेस और कस्टम मॉडल ट्रेनिंग शामिल है.

Vertex AI के एम्बेडिंग मॉडल का इस्तेमाल करने के लिए, अपने डिफ़ॉल्ट क्षेत्र को कॉन्फ़िगर किया जा सकता है. हालांकि, यह ज़रूरी नहीं है. Vertex AI की सुविधा देने वाले देशों/इलाकों के बारे में ज़्यादा जानें. इस उदाहरण में, हम us-central1 क्षेत्र का इस्तेमाल कर रहे हैं.

gcloud config set compute/region us-central1

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

AlloyDB क्लस्टर बनाने से पहले, हमें अपने वीपीसी में उपलब्ध निजी आईपी पते की एक रेंज की ज़रूरत होती है. इसका इस्तेमाल आने वाले समय में AlloyDB इंस्टेंस के लिए किया जाएगा. अगर हमारे पास यह नहीं है, तो हमें इसे बनाना होगा. साथ ही, इसे Google की आंतरिक सेवाओं के लिए इस्तेमाल करने की अनुमति देनी होगी. इसके बाद, हम क्लस्टर और इंस्टेंस बना पाएंगे.

निजी आईपी रेंज बनाना

हमें AlloyDB के लिए, अपने वीपीसी में निजी सेवा ऐक्सेस कॉन्फ़िगरेशन को कॉन्फ़िगर करना होगा. यहां यह मान लिया गया है कि प्रोजेक्ट में "डिफ़ॉल्ट" वीपीसी नेटवर्क है और इसका इस्तेमाल सभी कार्रवाइयों के लिए किया जाएगा.

निजी आईपी रेंज बनाएं:

gcloud compute addresses create psa-range \
    --global \
    --purpose=VPC_PEERING \
    --prefix-length=24 \
    --description="VPC private service access" \
    --network=default

अलॉट की गई आईपी रेंज का इस्तेमाल करके, निजी कनेक्शन बनाएं:

gcloud services vpc-peerings connect \
    --service=servicenetworking.googleapis.com \
    --ranges=psa-range \
    --network=default

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

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

इस सेक्शन में, हम us-central1 क्षेत्र में एक AlloyDB क्लस्टर बना रहे हैं.

postgres उपयोगकर्ता के लिए पासवर्ड तय करें. आपके पास अपना पासवर्ड तय करने या पासवर्ड जनरेट करने के लिए, रैंडम फ़ंक्शन का इस्तेमाल करने का विकल्प होता है

export PGPASSWORD=`openssl rand -hex 12`

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

student@cloudshell:~ (test-project-402417)$ export PGPASSWORD=`openssl rand -hex 12`

PostgreSQL का पासवर्ड नोट करें, ताकि इसे बाद में इस्तेमाल किया जा सके.

echo $PGPASSWORD

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

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

student@cloudshell:~ (test-project-402417)$ echo $PGPASSWORD
bbefbfde7601985b0dee5723

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

रीजन और AlloyDB क्लस्टर का नाम तय करें. हम us-central1 क्षेत्र और alloydb-hybrid-search को क्लस्टर के नाम के तौर पर इस्तेमाल करने जा रहे हैं:

export REGION=us-central1
export ADBCLUSTER=alloydb-hybrid-search

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

gcloud alloydb clusters create $ADBCLUSTER \
    --password=$PGPASSWORD \
    --network=default \
    --region=$REGION

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

export REGION=us-central1
export ADBCLUSTER=alloydb-hybrid-search
gcloud alloydb clusters create $ADBCLUSTER \
    --password=$PGPASSWORD \
    --network=default \
    --region=$REGION 
Operation ID: operation-1697655441138-6080235852277-9e7f04f5-2012fce4
Creating cluster...done.

उसी Cloud Shell सेशन में, हमारे क्लस्टर के लिए AlloyDB प्राइमरी इंस्टेंस बनाएं. अगर आपका कनेक्शन बंद हो जाता है, तो आपको क्षेत्र और क्लस्टर के नाम वाले एनवायरमेंट वैरिएबल फिर से तय करने होंगे.

gcloud alloydb instances create $ADBCLUSTER-pr \
    --instance-type=PRIMARY \
    --cpu-count=2 \
    --region=$REGION \
    --cluster=$ADBCLUSTER

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

student@cloudshell:~ (alloydb-hybrid-search)$ 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. AlloyDB से कनेक्ट करना

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

GCE वीएम डिप्लॉय करना

AlloyDB क्लस्टर के लिए, उसी इलाके और वीपीसी में एक GCE वीएम बनाएं.

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

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

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

student@cloudshell:~ (alloydb-hybrid-search)$ export ZONE=us-central1-a
student@cloudshell:~ (talloydb-hybrid-search)$ 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 इंस्टॉल करना

डिप्लॉय की गई वीएम पर, PostgreSQL क्लाइंट सॉफ़्टवेयर इंस्टॉल करें

वीएम से कनेक्ट करें:

gcloud compute ssh instance-1 --zone=us-central1-a

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

student@cloudshell:~ (alloydb-hybrid-search)$ gcloud compute ssh instance-1 --zone=us-central1-a
Updating project ssh metadata...working..Updated [https://www.googleapis.com/compute/v1/projects/alloydb-hybrid-search].                                                                                                                                                         
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:~$

वर्चुअल मशीन में, कमांड चलाने वाला सॉफ़्टवेयर इंस्टॉल करें:

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

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

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

इंस्टेंस से कनेक्ट करना

psql का इस्तेमाल करके, वीएम से प्राइमरी इंस्टेंस से कनेक्ट करें.

उसी Cloud Shell टैब में, जिसमें instance-1 वीएम के लिए SSH सेशन खुला है.

GCE वीएम से AlloyDB से कनेक्ट करने के लिए, AlloyDB के नोट किए गए पासवर्ड (PGPASSWORD) की वैल्यू और AlloyDB क्लस्टर आईडी का इस्तेमाल करें:

export PGPASSWORD=<Noted password>

export PROJECT_ID=$(gcloud config get-value project)
export REGION=us-central1
export ADBCLUSTER=alloydb-hybrid-search
export INSTANCE_IP=$(gcloud alloydb instances describe $ADBCLUSTER-pr --cluster=$ADBCLUSTER --region=$REGION --format="value(ipAddress)")
psql "host=$INSTANCE_IP user=postgres sslmode=require"

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

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

psql सेशन बंद करें:

exit

6. डेटाबेस तैयार करना

हमें एक डेटाबेस बनाना होगा. साथ ही, Vertex AI इंटिग्रेशन को चालू करना होगा. इसके अलावा, डेटाबेस ऑब्जेक्ट बनाने होंगे और डेटा इंपोर्ट करना होगा.

AlloyDB को ज़रूरी अनुमतियां देना

AlloyDB के सेवा एजेंट को Vertex AI की अनुमतियां दें.

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

नए क्लाउड शेल टैब में यह कमांड चलाएं:

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"

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

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

टैब में "exit" कमांड डालकर टैब बंद करें:

exit

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

quickstart नाम का डेटाबेस बनाएं.

GCE वीएम सेशन में यह कमांड चलाएं:

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

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

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

student@instance-1:~$ psql "host=$INSTANCE_IP user=postgres" -c "CREATE DATABASE quickstart_db"
CREATE DATABASE
student@instance-1:~$

Vertex AI इंटिग्रेशन चालू करना

डेटाबेस में Vertex AI इंटिग्रेशन और pgvector एक्सटेंशन चालू करें.

GCE वीएम में यह कमांड चलाएं:

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"

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

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

डेटा इंपोर्ट करना

तैयार किए गए डेटा को डाउनलोड करें और उसे नए डेटाबेस में इंपोर्ट करें.

GCE वीएम में यह कमांड चलाएं:

gcloud storage cat gs://cloud-training/gcc/gcc-tech-004/cymbal_demo_schema.sql |psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db"
gcloud storage 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"
gcloud storage 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"
gcloud storage 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"

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

student@instance-1:~$ gcloud storage 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:~$ gcloud storage 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:~$ gcloud storage 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:~$ gcloud storage 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. वेक्टर एम्बेडिंग जनरेट करना

डेटा इंपोर्ट करने के बाद, हमारे पास ये टेबल हैं: cymbal_products जिसमें प्रॉडक्ट के बारे में जानकारी सेव होती है, cymbal_inventory जो हर स्टोर में आइटम के स्टॉक को ट्रैक करती है, और cymbal_stores जो स्टोर की सूची है. अपने प्रॉडक्ट पर सिमैंटिक सर्च करने के लिए, हमें initialize_embeddings फ़ंक्शन का इस्तेमाल करके, अपने प्रॉडक्ट की जानकारी की वेक्टर एम्बेडिंग जनरेट करनी होगी. हम Vertex AI इंटिग्रेशन का इस्तेमाल करके, प्रॉडक्ट के ब्यौरे के आधार पर वेक्टर डेटा का हिसाब लगाएंगे और उसे टेबल में जोड़ेंगे. इस्तेमाल की गई टेक्नोलॉजी के बारे में ज़्यादा जानने के लिए, दस्तावेज़ पढ़ें.

इंटिग्रेशन का इस्तेमाल करने के लिए, AlloyDB इंस्टेंस के आईपी और postgres पासवर्ड का इस्तेमाल करके, अपनी वीएम से psql का इस्तेमाल करके डेटाबेस से कनेक्ट करें:

psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db"

google_ml_integration एक्सटेंशन के वर्शन की पुष्टि करें.

SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';

वर्शन 1.5.2 या इसके बाद का होना चाहिए. यहां आउटपुट का उदाहरण दिया गया है:

quickstart_db=> SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';
 extversion 
------------
 1.5.2
(1 row)

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

ध्यान दें: एक्सटेंशन के वर्शन को बैकएंड पर अपने-आप मैनेज किया जाता है. psql सेशन में इस तरह का कमांड चलाकर, एक्सटेंशन को अपडेट करने की कोशिश की जा सकती है:

ALTER EXTENSION google_ml_integration UPDATE;

अगर यह तरीका काम नहीं करता है, तो पैकेज के लिए झलक वर्शन चालू करने वाली प्रक्रिया को कॉल करें. प्रोडक्शन में झलक वर्शन का इस्तेमाल न करें

CALL google_ml.upgrade_to_preview_version();

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

show google_ml_integration.enable_faster_embedding_generation;

अगर फ़्लैग सही जगह पर है, तो अनुमानित आउटपुट ऐसा दिखेगा:

quickstart_db=> show google_ml_integration.enable_faster_embedding_generation;                          
 google_ml_integration.enable_faster_embedding_generation 
----------------------------------------------------------
 on
(1 row)

हालांकि, अगर यह "बंद है" के तौर पर दिखता है, तो हमें इंस्टेंस को अपडेट करना होगा. इसे वेब कंसोल या gcloud कमांड का इस्तेमाल करके किया जा सकता है. इसके बारे में दस्तावेज़ में बताया गया है. यहां gcloud कमांड का इस्तेमाल करके, ऐसा करने का तरीका बताया गया है:

export PROJECT_ID=$(gcloud config get-value project)
export REGION=us-central1
export ADBCLUSTER=alloydb-hybrid-search
gcloud beta alloydb instances update $ADBCLUSTER-pr \
   --database-flags google_ml_integration.enable_faster_embedding_generation=on \
   --region=$REGION \
   --cluster=$ADBCLUSTER \
   --project=$PROJECT_ID \
   --update-mode=FORCE_APPLY

इसमें कुछ मिनट लग सकते हैं. हालांकि, कुछ समय बाद फ़्लैग की वैल्यू "चालू है" पर सेट हो जाएगी. इसके बाद, अगले चरण पर जाएं.

psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db"

डेटाबेस से कनेक्ट किए गए psql सेशन में, cymbal_products में एम्बेडिंग सेव करने के लिए एक नया कॉलम बनाएं

ALTER TABLE cymbal_products ADD COLUMN product_embedding vector(768);

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

quickstart_db=> ALTER TABLE cymbal_products ADD COLUMN product_embedding vector(768);
ALTER TABLE
quickstart_db=>

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

अब इन सभी को एक साथ रखकर एम्बेडिंग जनरेट करने के लिए, हम initialize_embeddings फ़ंक्शन का इस्तेमाल करते हैं. साथ ही, बैच के लिए 50 को batch_size के तौर पर पास करते हैं और incremental_refresh_mode को transactional पर सेट करते हैं

CALL ai.initialize_embeddings(
    model_id => 'text-embedding-005',
    table_name => 'cymbal_products',
    content_column => 'product_description',
    embedding_column => 'product_embedding',
    batch_size => 50,
    incremental_refresh_mode => 'transactional'
);

अब अगर हम टेबल में एक नई लाइन जोड़ते हैं, जिसमें product_embedding कॉलम के लिए NULL वैल्यू है

INSERT INTO "cymbal_products" ("uniq_id", "crawl_timestamp", "product_url", "product_name", "product_description", "list_price", "sale_price", "brand", "item_number", "gtin", "package_size", "category", "postal_code", "available", "product_embedding") VALUES ('fd604542e04b470f9e6348e640cff794', NOW(), 'https://example.com/new_product', 'New Cymbal Product', 'This is a new cymbal product description.', 199.99, 149.99, 'Example Brand', 'EB123', '1234567890', 'Single', 'Cymbals', '12345', TRUE, NULL);

अब जब हम उस लाइन के बारे में क्वेरी करेंगे जिसे हमने अभी डाला है, तो हमें दिखेगा कि product_embedding कॉलम अपने-आप अपडेट हो गया है.

SELECT uniq_id, (product_embedding::real[])[1:5] as product_embedding  FROM cymbal_products WHERE uniq_id='fd604542e04b470f9e6348e640cff794';

आउटपुट ऐसा दिखना चाहिए:

quickstart_db=> SELECT uniq_id,(product_embedding::real[])[1:5] as product_embedding  FROM cymbal_products WHERE uniq_id='fd604542e04b470f9e6348e640cff794';
             uniq_id              |                      product_embedding                       
----------------------------------+---------------------------------------------------------------
 fd604542e04b470f9e6348e640cff794 | {0.015003494,-0.005349732,-0.059790313,-0.0087091,-0.0271452}
(1 row)

Time: 3.295 ms

8. वेक्टर इंडेक्स बनाना

वेक्टर सर्च की परफ़ॉर्मेंस को बेहतर बनाने के लिए, हम ScaNN इंडेक्स जोड़ेंगे.

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

SCANN इंडेक्स बनाने के लिए, हमें एक और एक्सटेंशन चालू करना होगा. alloydb_scann एक्सटेंशन, Google के ScaNN एल्गोरिदम का इस्तेमाल करके, ANN टाइप के वेक्टर इंडेक्स के साथ काम करने के लिए इंटरफ़ेस उपलब्ध कराता है.

CREATE EXTENSION IF NOT EXISTS alloydb_scann;

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

quickstart_db=> CREATE EXTENSION IF NOT EXISTS alloydb_scann;
CREATE EXTENSION
Time: 27.468 ms
quickstart_db=>

इंडेक्स को मैन्युअल या ऑटो मोड में बनाया जा सकता है. मैन्युअल मोड डिफ़ॉल्ट रूप से चालू होता है. इसमें किसी भी अन्य इंडेक्स की तरह इंडेक्स बनाया और उसे मैनेज किया जा सकता है. हालांकि, AUTO मोड चालू करने पर, ऐसा इंडेक्स बनाया जा सकता है जिसे आपको मैनेज करने की ज़रूरत नहीं होती. सभी विकल्पों के बारे में ज़्यादा जानकारी पाने के लिए, दस्तावेज़ पढ़ें. हमारे मामले में, ऑटो मोड में इंडेक्स बनाने के लिए हमारे पास ज़रूरत के मुताबिक लाइनें नहीं हैं. इसलिए, हम इसे मैन्युअल मोड में बनाएंगे और इसमें ट्यूनिंग पैरामीटर शामिल करेंगे. दस्तावेज़ में जाकर, इंडेक्स पैरामीटर को ट्यून करने के बारे में पढ़ें.

हमें scann.enable_preview_features फ़्लैग चालू करना होगा, ताकि हम ट्यूनिंग पैरामीटर में बदलाव कर सकें. Cloud Shell में

export PROJECT_ID=$(gcloud config get-value project)
export REGION=us-central1
export ADBCLUSTER=alloydb-hybrid-search
gcloud beta alloydb instances update $ADBCLUSTER-pr \
   --database-flags scann.enable_preview_features=on \
   --region=$REGION \
   --cluster=$ADBCLUSTER \
   --project=$PROJECT_ID \
   --update-mode=FORCE_APPLY

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

CREATE INDEX cymbal_products_embeddings_scann ON cymbal_products
  USING scann (product_embedding cosine)
  WITH (mode='MANUAL', num_leaves=31, max_num_levels = 2);

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

quickstart_db=> CREATE INDEX cymbal_products_embeddings_scann ON cymbal_products
  USING scann (product_embedding cosine)
  WITH (num_leaves=31, max_num_levels = 2);
CREATE INDEX
quickstart_db=>

इंडेक्स के इस्तेमाल की जांच करना

अब हम EXPLAIN मोड में वेक्टर सर्च क्वेरी चला सकते हैं. साथ ही, यह पुष्टि कर सकते हैं कि इंडेक्स का इस्तेमाल किया जा रहा है या नहीं.

EXPLAIN (analyze) 
WITH trees as (
SELECT
        cp.product_name,
        left(cp.product_description,80) as description,
        cp.sale_price,
        cs.zip_code,
        cp.uniq_id as product_id
FROM
        cymbal_products cp
JOIN cymbal_inventory ci on
        ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
        cs.store_id=ci.store_id
        AND ci.inventory>0
        AND cs.store_id = 1583
ORDER BY
        (cp.product_embedding <=> embedding('text-embedding-005','What kind of fruit trees grow well here?')::vector) ASC
LIMIT 1)
SELECT json_agg(trees) FROM trees;

अनुमानित आउटपुट (ज़्यादा जानकारी के लिए, कुछ हिस्सा छिपा दिया गया है):

...
Aggregate (cost=16.59..16.60 rows=1 width=32) (actual time=2.875..2.877 rows=1 loops=1)
-> Subquery Scan on trees (cost=8.42..16.59 rows=1 width=142) (actual time=2.860..2.862 rows=1 loops=1)
-> Limit (cost=8.42..16.58 rows=1 width=158) (actual time=2.855..2.856 rows=1 loops=1)
-> Nested Loop (cost=8.42..6489.19 rows=794 width=158) (actual time=2.854..2.855 rows=1 loops=1)
-> Nested Loop (cost=8.13..6466.99 rows=794 width=938) (actual time=2.742..2.743 rows=1 loops=1)
-> Index Scan using cymbal_products_embeddings_scann on cymbal_products cp (cost=7.71..111.99 rows=876 width=934) (actual time=2.724..2.724 rows=1 loops=1)
Order By: (embedding <=> '[0.008864171,0.03693164,-0.024245683,-0.00355923,0.0055611245,0.015985578,...<redacted>...5685,-0.03914233,-0.018452475,0.00826032,-0.07372604]'::vector)
...

आउटपुट से हमें साफ़ तौर पर पता चलता है कि क्वेरी में "cymbal_products_embeddings_scann on cymbal_products" का इस्तेमाल किया गया था.

9. पूरे टेक्स्ट की खोज के लिए इंडेक्स

AlloyDB, फ़ुल-टेक्स्ट सर्च के लिए उन सभी इंडेक्स टाइप के साथ काम करता है जिनके साथ नेटिव PostgreSQL काम करता है. इंडेक्स का चुनाव, खोज के नतीजे मिलने में लगने वाले समय, इंडेक्स बनाने में लगने वाले समय, अपडेट होने में लगने वाले समय, और खोज के लिए ज़रूरी खास सुविधाओं के बीच संतुलन पर निर्भर करता है. जैसे, वाक्यांश खोजना या काम के हिसाब से रैंकिंग करना.

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

rum एक्सटेंशन चालू करने के लिए, AlloyDB Studio का इस्तेमाल किया जा सकता है या psql क्लाइंट का इस्तेमाल जारी रखा जा सकता है

आरयूएम इंडेक्स बनाना

CREATE EXTENSION IF NOT EXISTS rum;

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

ALTER TABLE cymbal_products
ADD COLUMN product_search_vector tsvector
GENERATED ALWAYS AS (to_tsvector('english', product_description)) STORED;

अब हम product_search_vector कॉलम के लिए, नया आरयूएम इंडेक्स बना सकते हैं.

CREATE INDEX cymbal_products_rum
ON cymbal_products
USING rum (product_search_vector rum_tsvector_ops);

इंडेक्स का इस्तेमाल करके टेबल से क्वेरी करने के लिए, यह क्वेरी चलाएं. यह क्वेरी "cherry tree" से मिलते-जुलते शब्दों को खोजती है. <=> ऑपरेटर, इंडेक्स से सीधे तौर पर दस्तावेज़ और क्वेरी के बीच के काम के स्कोर या दूरी का हिसाब लगाता है.

SELECT product_name, product_description
FROM cymbal_products
WHERE product_search_vector @@ to_tsquery('english', 'cherry <-> tree')
ORDER BY product_search_vector <=> to_tsquery('english', 'cherry <-> tree');

10. हाइब्रिड सर्च करना

google_vector_utils.hybrid_search() फ़ंक्शन की मदद से, खोज के अलग-अलग टाइप के नतीजों को एक साथ देखा जा सकता है. जैसे, वेक्टर सर्च और पूरे टेक्स्ट की खोज. यह फ़ंक्शन, Reciprocal Rank Fusion (RRF) एल्गोरिदम का इस्तेमाल करके, खोज के हर कॉम्पोनेंट से मिले रैंक किए गए नतीजों को एक ही सूची में जोड़ता है. इस तरीके से, सिर्फ़ एक तरह की खोज के मुकाबले ज़्यादा काम के नतीजे मिलते हैं.

hybrid_search() फ़ंक्शन, एक एसक्यूएल क्वेरी को डाइनैमिक तरीके से बनाता है और उसे लागू करता है. यह आपके तय किए गए हर सर्च कॉम्पोनेंट के लिए, एक कॉमन टेबल एक्सप्रेशन (सीटीई) बनाता है. इसके बाद, यह फ़ंक्शन सभी सीटीई के नतीजों को जोड़ता है और हर दस्तावेज़ के लिए फ़ाइनल आरआरएफ़ स्कोर का हिसाब लगाता है, ताकि एक ही रैंक वाली सूची तैयार की जा सके.

इस फ़ंक्शन का इस्तेमाल करने के लिए, हमें प्राइमरी इंस्टेंस में enable_preview_ai_functions चालू करना होगा. Cloud Shell में यह कमांड चलाएं

export PROJECT_ID=$(gcloud config get-value project)
export REGION=us-central1
export ADBCLUSTER=alloydb-hybrid-search
gcloud beta alloydb instances update $ADBCLUSTER-pr \
   --database-flags google_ml_integration.enable_preview_ai_functions=on \
   --region=$REGION \
   --cluster=$ADBCLUSTER \
   --project=$PROJECT_ID \
   --update-mode=FORCE_APPLY

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

SELECT score, id, p.product_name
FROM ai.hybrid_search(
  search_inputs => ARRAY[
      '{
        "data_type": "vector",
        "table_name": "cymbal_products",
        "key_column": "uniq_id",
        "vec_column": "product_embedding",
        "distance_operator": "public.<=>",
        "limit": 5,
        "query_vector": "ai.embedding(''text-embedding-005'', ''cherry'')::vector"
      }'::JSONB,
      '{
        "data_type": "text",
        "table_name": "cymbal_products",
        "key_column": "uniq_id",
        "text_column": "product_search_vector",
        "limit": 5,
        "ranking_function": "<=>",
        "query_text_input": "tree"
      }'::JSONB
  ]
) JOIN cymbal_products p ON id = p.uniq_id;

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

"score","id","product_name"
"0.00819672631147241","d536e9e823296a2eba198e52dd23e712","Cherry Tree"
"0.015873015873015872","23e41a71d63d8bbc9bdfa1d118cfddc5","Apple Tree"
"0.00819672631147241","dc789a2f87b142e94e6e325689482af9","Oak Tree"
"0.008064521129029258","f5c70d62ccf3118d73863bf3b17edcbe","Cypress Tree"
"0.008064521129029258","b70c44b1a38c0a2329fa583c9109a80f","Peach Tree"

नतीजों में आपको id दिखेगा, जो key_column के लिए तय की गई वैल्यू है. साथ ही, score वह फ़ाइनल वैल्यू है जिसे RRF ने कैलकुलेट किया है. रेसिप्रोकल रैंक फ़्यूज़न (आरआरएफ़), रैंक पर आधारित एक एल्गोरिदम है. यह खोज के नतीजों की रैंक वाली कई सूचियों को एक ही रैंक वाली सूची में जोड़ता है. इसके लिए, यह हर दस्तावेज़ को एक स्कोर असाइन करता है. यह स्कोर, उन सभी सूचियों में RRF की रैंक के आधार पर तय किया जाता है जिनमें दस्तावेज़ शामिल किए गए हैं. इसमें ज़्यादा रैंक वाले दस्तावेज़ों को ज़्यादा अहमियत दी जाती है. पैरामीटर में include_json_output => true का इस्तेमाल करने पर, detail_json कॉलम दिखेगा. इसमें हर कॉम्पोनेंट के लिए, स्कोर कैलकुलेट करने की जानकारी होगी.

फ़ुल-टेक्स्ट सर्च, किसी खास शब्द या एग्ज़ैक्ट मैच को ढूंढने में सबसे अच्छी होती है. वहीं, वेक्टर सर्च, मिलते-जुलते शब्दों और इंटेंट को ढूंढने में बेहतर होती है. भले ही, शब्द मेल न खाएं. इन दोनों तरीकों को मिलाकर हाइब्रिड सर्च यह पक्का करती है कि उपयोगकर्ताओं को नतीजों का एक मज़बूत सेट मिले. ये नतीजे, शब्दों के हिसाब से सटीक होने के साथ-साथ मतलब के हिसाब से भी काम के होते हैं

11. पर्यावरण को साफ़-सुथरा रखना

लैब का काम पूरा हो जाने के बाद, AlloyDB इंस्टेंस और क्लस्टर को मिटा दें.

AlloyDB क्लस्टर और सभी इंस्टेंस मिटाना

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

फ़ोर्स विकल्प का इस्तेमाल करके क्लस्टर को डिस्ट्रॉय किया जाता है. इससे क्लस्टर से जुड़े सभी इंस्टेंस भी मिट जाते हैं.

अगर आपका कनेक्शन बंद हो गया है और पिछली सभी सेटिंग मिट गई हैं, तो क्लाउड शेल में प्रोजेक्ट और एनवायरमेंट वैरिएबल तय करें:

gcloud config set project <your project id>

export REGION=us-central1
export ADBCLUSTER=alloydb-hybrid-search
export PROJECT_ID=$(gcloud config get-value project)

क्लस्टर मिटाने के लिए:

gcloud alloydb clusters delete $ADBCLUSTER --region=$REGION --force

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

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 के बैकअप मिटाना

क्लस्टर के सभी AlloyDB बैकअप मिटाने के लिए:

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

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

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.

अब हम अपने वीएम को डिस्ट्रॉय कर सकते हैं

GCE वीएम मिटाएं

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

export GCEVM=instance-1
export ZONE=us-central1-a
gcloud compute instances delete $GCEVM \
    --zone=$ZONE \
    --quiet

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

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

12. बधाई हो

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

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

AlloyDB क्लस्टर और प्राइमरी इंस्टेंस को डिप्लॉय करने का तरीका
Google Compute Engine वीएम से AlloyDB से कनेक्ट करने का तरीका
डेटाबेस बनाने और AlloyDB AI को चालू करने का तरीका
डेटाबेस में डेटा लोड करने का तरीका
AlloyDB Studio का इस्तेमाल कैसे करें
Vertex AI की मदद से एम्बेडिंग जनरेट करना
वेक्टर सर्च को बेहतर बनाने के लिए, ScaNN वेक्टर इंडेक्स बनाने का तरीका
फ़ुल-टेक्स्ट सर्च के लिए, RUM एक्सटेंशन को चालू और इस्तेमाल करने का तरीका
फ़ुल-टेक्स्ट सर्च, वेक्टर सर्च, और रेसिप्रोकल रैंक फ़्यूज़न (आरआरएफ़) को मिलाकर हाइब्रिड सर्च करना