Utilizza Private Service Connect per accedere a un indice di Vector Search da on-premise

Crea le reti VPC

In questa sezione creerai due reti VPC: una per la creazione di un indice Vector Search e il relativo deployment in un endpoint, l'altra per l'accesso privato a quell'endpoint.

Crea la rete VPC per l'endpoint indice di Vector Search (vertex-networking-vpc)

1. Crea la rete VPC per l'endpoint indice:

   gcloud compute networks create vertex-networking-vpc --project=$projectid --subnet-mode custom
   

2. Crea una subnet denominata workbench-subnet, con un intervallo IPv4 principale 172.16.20.0/28:

   gcloud compute networks subnets create workbench-subnet \
     --project=$projectid --range=172.16.20.0/28 \
     --network=vertex-networking-vpc \
     --region=us-central1 \
     --enable-private-ip-google-access
   

3. Crea una subnet denominata consumer-endpoint-subnet, con un intervallo IPv4 principale 172.16.30.0/28:

   gcloud compute networks subnets create consumer-endpoint-subnet \
     --project=$projectid \
     --range=172.16.30.0/28 \
     --network=vertex-networking-vpc \
     --region=us-central1 \
     --enable-private-ip-google-access
   

Crea la rete VPC per l'accesso privato all'endpoint (onprem-vpc)

1. Crea la rete VPC per simulare la rete on-premise (onprem-vpc):

   gcloud compute networks create onprem-vpc \
     --subnet-mode custom
   

2. Nella rete onprem-vpc, crea una subnet denominata onprem-vpc-subnet1, con un intervallo IPv4 principale 172.16.10.0/29:

   gcloud compute networks subnets create onprem-vpc-subnet1 \
     --network onprem-vpc \
     --range 172.16.10.0/29 \
     --region us-central1
   

Verifica che le reti VPC siano configurate correttamente

1. Nella console Google Cloud, vai alla scheda Reti nel progetto attuale nella pagina Reti VPC.

   Vai a Reti VPC

2. Nell'elenco delle reti VPC, verifica che siano state create le due reti: vertex-networking-vpc e onprem-vpc.

3. Fai clic sulla scheda Subnet nel progetto corrente.

4. Nell'elenco delle subnet VPC, verifica che siano state create le subnet workbench-subnet, consumer-endpoint-subnet e onprem-vpc-subnet1.

Crea l'istanza VM on-prem-client

In questa sezione creerai un'istanza VM per rappresentare un'applicazione client che invia richieste all'endpoint dell'indice di Vector Search tramite VPN ad alta disponibilità.

1. In Cloud Shell, crea l'istanza VM on-prem-client:

   gcloud compute instances create on-prem-client \
     --zone=us-central1-a \
     --image-family=debian-11 \
     --image-project=debian-cloud \
     --subnet=onprem-vpc-subnet1 \
     --scopes=http://www.googleapis.com/auth/cloud-platform \
     --no-address \
     --shielded-secure-boot \
     --metadata startup-script="#! /bin/bash
       sudo apt-get update
       sudo apt-get install tcpdump dnsutils -y"
   
   

Configura la connettività ibrida

In questa sezione creerai due gateway VPN ad alta disponibilità connessi tra loro. Uno si trova nella rete VPC vertex-networking-vpc. L'altro si trova nella rete VPC onprem-vpc. Ogni gateway contiene un router Cloud e una coppia di tunnel VPN.

Crea i gateway VPN ad alta disponibilità

1. In Cloud Shell, crea il gateway VPN ad alta disponibilità per la rete VPC vertex-networking-vpc:

   gcloud compute vpn-gateways create vertex-networking-vpn-gw1 \
      --network vertex-networking-vpc \
      --region us-central1
   

2. Crea il gateway VPN ad alta disponibilità per la rete VPC onprem-vpc:

   gcloud compute vpn-gateways create onprem-vpn-gw1 \
      --network onprem-vpc \
      --region us-central1
   

3. Nella console Google Cloud, vai alla scheda Gateway Cloud VPN nella pagina VPN.

   Vai alla VPN

4. Verifica che i due gateway (vertex-networking-vpn-gw1 e onprem-vpn-gw1) siano stati creati e che ciascuno abbia due indirizzi IP di interfaccia.

crea router Cloud e gateway Cloud NAT

In ciascuna delle due reti VPC, crei due router Cloud: uno generale e uno a livello di regione. In ognuno dei router Cloud a livello di regione, crea un gateway Cloud NAT. I gateway Cloud NAT forniscono connettività in uscita per le istanze di macchine virtuali (VM) Compute Engine che non hanno indirizzi IP esterni.

1. In Cloud Shell, crea un router Cloud per la rete VPC vertex-networking-vpc:

   gcloud compute routers create vertex-networking-vpc-router1 \
      --region us-central1\
      --network vertex-networking-vpc \
      --asn 65001
   

2. Crea un router Cloud per la rete VPC onprem-vpc:

   gcloud compute routers create onprem-vpc-router1 \
      --region us-central1\
      --network onprem-vpc\
      --asn 65002
   

3. Crea un router Cloud a livello di regione per la rete VPC vertex-networking-vpc:

   gcloud compute routers create cloud-router-us-central1-vertex-nat \
     --network vertex-networking-vpc \
     --region us-central1
   

4. Configura un gateway Cloud NAT sul router Cloud a livello di regione:

   gcloud compute routers nats create cloud-nat-us-central1 \
     --router=cloud-router-us-central1-vertex-nat \
     --auto-allocate-nat-external-ips \
     --nat-all-subnet-ip-ranges \
     --region us-central1
   

5. Crea un router Cloud a livello di regione per la rete VPC onprem-vpc:

   gcloud compute routers create cloud-router-us-central1-onprem-nat \
     --network onprem-vpc \
     --region us-central1
   

6. Configura un gateway Cloud NAT sul router Cloud a livello di regione:

   gcloud compute routers nats create cloud-nat-us-central1-on-prem \
     --router=cloud-router-us-central1-onprem-nat \
     --auto-allocate-nat-external-ips \
     --nat-all-subnet-ip-ranges \
     --region us-central1
   

7. Nella console Google Cloud, vai alla pagina Router Cloud.

   Vai ai router Cloud

8. Nell'elenco Router Cloud, verifica che siano stati creati i seguenti router:

   • cloud-router-us-central1-onprem-nat
   • cloud-router-us-central1-vertex-nat
   • onprem-vpc-router1
   • vertex-networking-vpc-router1

   Per visualizzare i nuovi valori, potrebbe essere necessario aggiornare la scheda del browser della console Google Cloud.

9. Nell'elenco dei router Cloud, fai clic su cloud-router-us-central1-vertex-nat.

10. Nella pagina Dettagli router, verifica che il gateway Cloud NAT cloud-nat-us-central1 sia stato creato.

11. Fai clic sulla arrow_backFreccia indietro per tornare alla pagina Router Cloud.

12. Nell'elenco di router, fai clic su cloud-router-us-central1-onprem-nat.

13. Nella pagina Dettagli router, verifica che il gateway Cloud NAT cloud-nat-us-central1-on-prem sia stato creato.

Crea tunnel VPN

1. In Cloud Shell, nella rete vertex-networking-vpc, crea un tunnel VPN denominato vertex-networking-vpc-tunnel0:

   gcloud compute vpn-tunnels create vertex-networking-vpc-tunnel0 \
     --peer-gcp-gateway onprem-vpn-gw1 \
     --region us-central1 \
     --ike-version 2 \
     --shared-secret [ZzTLxKL8fmRykwNDfCvEFIjmlYLhMucH] \
     --router vertex-networking-vpc-router1 \
     --vpn-gateway vertex-networking-vpn-gw1 \
     --interface 0
   

2. Nella rete vertex-networking-vpc, crea un tunnel VPN denominato vertex-networking-vpc-tunnel1:

   gcloud compute vpn-tunnels create vertex-networking-vpc-tunnel1 \
     --peer-gcp-gateway onprem-vpn-gw1 \
     --region us-central1 \
     --ike-version 2 \
     --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \
     --router vertex-networking-vpc-router1 \
     --vpn-gateway vertex-networking-vpn-gw1 \
     --interface 1
   

3. Nella rete onprem-vpc, crea un tunnel VPN denominato onprem-vpc-tunnel0:

   gcloud compute vpn-tunnels create onprem-vpc-tunnel0 \
     --peer-gcp-gateway vertex-networking-vpn-gw1 \
     --region us-central1\
     --ike-version 2 \
     --shared-secret [ZzTLxKL8fmRykwNDfCvEFIjmlYLhMucH] \
     --router onprem-vpc-router1 \
     --vpn-gateway onprem-vpn-gw1 \
     --interface 0
   

4. Nella rete onprem-vpc, crea un tunnel VPN denominato onprem-vpc-tunnel1:

   gcloud compute vpn-tunnels create onprem-vpc-tunnel1 \
     --peer-gcp-gateway vertex-networking-vpn-gw1 \
     --region us-central1\
     --ike-version 2 \
     --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \
     --router onprem-vpc-router1 \
     --vpn-gateway onprem-vpn-gw1 \
     --interface 1
   

5. Nella console Google Cloud, vai alla pagina VPN.

   Vai alla VPN

6. Nell'elenco dei tunnel VPN, verifica che siano stati creati i quattro tunnel VPN.

Definizione di sessioni BGP

Il router Cloud utilizza il protocollo BGP (Border Gateway Protocol) per scambiare le route tra la tua rete VPC (in questo caso, vertex-networking-vpc) e la tua rete on-premise (rappresentata da onprem-vpc). Sul router Cloud, configuri un'interfaccia e un peer BGP per il tuo router on-premise. L'interfaccia e la configurazione del peer BGP formano insieme una sessione BGP. In questa sezione creerai due sessioni BGP per vertex-networking-vpc e due per onprem-vpc.

Una volta configurate le interfacce e i peer BGP tra i router, questi inizieranno automaticamente a scambiare le route.

Stabilisci sessioni BGP per vertex-networking-vpc

1. In Cloud Shell, nella rete vertex-networking-vpc, crea un'interfaccia BGP per vertex-networking-vpc-tunnel0:

   gcloud compute routers add-interface vertex-networking-vpc-router1 \
     --interface-name if-tunnel0-to-onprem \
     --ip-address 169.254.0.1 \
     --mask-length 30 \
     --vpn-tunnel vertex-networking-vpc-tunnel0 \
     --region us-central1
   

2. Nella rete vertex-networking-vpc, crea un peer BGP per bgp-onprem-tunnel0:

   gcloud compute routers add-bgp-peer vertex-networking-vpc-router1 \
     --peer-name bgp-onprem-tunnel0 \
     --interface if-tunnel0-to-onprem \
     --peer-ip-address 169.254.0.2 \
     --peer-asn 65002 \
     --region us-central1
   

3. Nella rete vertex-networking-vpc, crea un'interfaccia BGP per vertex-networking-vpc-tunnel1:

   gcloud compute routers add-interface vertex-networking-vpc-router1 \
     --interface-name if-tunnel1-to-onprem \
     --ip-address 169.254.1.1 \
     --mask-length 30 \
     --vpn-tunnel vertex-networking-vpc-tunnel1 \
     --region us-central1
   

4. Nella rete vertex-networking-vpc, crea un peer BGP per bgp-onprem-tunnel1:

   gcloud compute routers add-bgp-peer vertex-networking-vpc-router1 \
     --peer-name bgp-onprem-tunnel1 \
     --interface if-tunnel1-to-onprem \
     --peer-ip-address 169.254.1.2 \
     --peer-asn 65002 \
     --region us-central1
   

Stabilisci sessioni BGP per onprem-vpc

1. Nella rete onprem-vpc, crea un'interfaccia BGP per onprem-vpc-tunnel0:

   gcloud compute routers add-interface onprem-vpc-router1 \
     --interface-name if-tunnel0-to-vertex-networking-vpc \
     --ip-address 169.254.0.2 \
     --mask-length 30 \
     --vpn-tunnel onprem-vpc-tunnel0 \
     --region us-central1
   

2. Nella rete onprem-vpc, crea un peer BGP per bgp-vertex-networking-vpc-tunnel0:

   gcloud compute routers add-bgp-peer onprem-vpc-router1 \
     --peer-name bgp-vertex-networking-vpc-tunnel0 \
     --interface if-tunnel0-to-vertex-networking-vpc \
     --peer-ip-address 169.254.0.1 \
     --peer-asn 65001 \
     --region us-central1
   

3. Nella rete onprem-vpc, crea un'interfaccia BGP per onprem-vpc-tunnel1:

   gcloud compute routers add-interface   onprem-vpc-router1  \
     --interface-name if-tunnel1-to-vertex-networking-vpc \
     --ip-address 169.254.1.2 \
     --mask-length 30 \
     --vpn-tunnel onprem-vpc-tunnel1 \
     --region us-central1
   

4. Nella rete onprem-vpc, crea un peer BGP per bgp-vertex-networking-vpc-tunnel1:

   gcloud compute routers add-bgp-peer onprem-vpc-router1 \
     --peer-name bgp-vertex-networking-vpc-tunnel1 \
     --interface if-tunnel1-to-vertex-networking-vpc \
     --peer-ip-address 169.254.1.1 \
     --peer-asn 65001 \
     --region us-central1
   

Convalida la creazione di sessioni BGP

1. Nella console Google Cloud, vai alla pagina VPN.

   Vai alla VPN

2. Nell'elenco dei tunnel VPN, verifica che il valore nella colonna Stato sessione BGP per ciascuno dei tunnel sia cambiato da Configura sessione BGP in BGP stabilito. Per visualizzare i nuovi valori, potresti dover aggiornare la scheda del browser della console Google Cloud.

Convalida vertex-networking-vpc route apprese

1. Nella console Google Cloud, vai alla pagina Reti VPC.

   Vai a Reti VPC

2. Nell'elenco delle reti VPC, fai clic su vertex-networking-vpc.

3. Fai clic sulla scheda Route.

4. Seleziona us-central1 (Iowa) nell'elenco Regione e fai clic su Visualizza.

5. Nella colonna Intervallo IP di destinazione, verifica che l'intervallo IP della subnet onprem-vpc-subnet1 (172.16.10.0/29) sia presente due volte.

Convalida on-prem-vpc route apprese

1. Fai clic sulla arrow_backFreccia indietro per tornare alla pagina Reti VPC.

2. Nell'elenco delle reti VPC, fai clic su on-prem-vpc.

3. Fai clic sulla scheda Route.

4. Seleziona us-central1 (Iowa) nell'elenco Regione e fai clic su Visualizza.

5. Nella colonna Intervallo IP di destinazione, verifica che l'intervallo IP della subnet workbench-subnet (172.16.20.0/28) e l'intervallo IP della subnet consumer-endpoint-subnet (172.16.30.0/28) vengano visualizzati due volte.

crea un'istanza di Vertex AI Workbench

In questa sezione creerai un account di servizio gestito dall'utente e poi creerai un'istanza di Vertex AI Workbench che utilizza il tuo account di servizio per accedere ai servizi e alle API Google Cloud.

Crea un account di servizio

In questo tutorial creerai un account di servizio gestito dall'utente seguendo le best practice di Compute Engine e IAM.

1. In Cloud Shell, crea un account di servizio denominato workbench-sa:

   gcloud iam service-accounts create workbench-sa \
      --display-name="workbench-sa"
   

2. Assegna il ruolo IAM Utente Vertex AI (roles/aiplatform.user) all'account di servizio:

   gcloud projects add-iam-policy-binding $projectid \
     --member="serviceAccount:workbench-sa@$projectid.iam.gserviceaccount.com" \
     --role="roles/aiplatform.user"
   

3. Assegna il ruolo IAM Amministratore archiviazione (roles/storage.admin) all'account di servizio:

   gcloud projects add-iam-policy-binding $projectid \
     --member="serviceAccount:workbench-sa@$projectid.iam.gserviceaccount.com" \
     --role="roles/storage.admin"
   

4. Assegna il ruolo IAM Amministratore Service Usage (roles/serviceusage.serviceUsageAdmin) all'account di servizio:

   gcloud projects add-iam-policy-binding $projectid \
     --member="serviceAccount:workbench-sa@$projectid.iam.gserviceaccount.com" \
     --role="roles/serviceusage.serviceUsageAdmin"
   

Crea l'istanza di Vertex AI Workbench

Crea un'istanza di Vertex AI Workbench, specificando l'account di servizio workbench-sa:

gcloud workbench instances create workbench-tutorial \
  --vm-image-project=deeplearning-platform-release \
  --vm-image-family=common-cpu-notebooks \
  --machine-type=n1-standard-4 \
  --location=us-central1-a \
  --subnet-region=us-central1 \
  --shielded-secure-boot=SHIELDED_SECURE_BOOT \
  --subnet=workbench-subnet \
  --disable-public-ip \
  --service-account-email=workbench-sa@$projectid.iam.gserviceaccount.com

Crea ed esegui il deployment di un indice di Vector Search

prepara l'ambiente

1. Nella console Google Cloud, vai alla scheda Istanze nella pagina Vertex AI Workbench.

   Vai a Vertex AI Workbench

2. Accanto al nome dell'istanza di Vertex AI Workbench (workbench-tutorial), fai clic su Apri JupyterLab.

   L'istanza di Vertex AI Workbench apre JupyterLab.

3. Seleziona File > Nuovo > Blocco note.

4. Dal menu Seleziona kernel, seleziona Python 3 (locale) e fai clic su Seleziona.

5. Quando si apre il nuovo blocco note, c'è una cella di codice predefinita in cui puoi inserire il codice. [ ]: seguito da un campo di testo. Il campo di testo è il campo in cui incolli il codice.

   Per installare l'SDK Vertex AI per Python, incolla il seguente codice nella cella e fai clic su play_arrow Esegui le celle selezionate e avanza:

   !pip install --upgrade --user google-cloud-aiplatform google-cloud-storage
   

6. In questo passaggio e in ciascuno di quelli seguenti, aggiungi una nuova cella di codice (se necessario) facendo clic su add Inserisci una cella qui sotto, incolla il codice nella cella e fai clic su play_arrow Esegui le celle selezionate e avanza.

   Per utilizzare i pacchetti appena installati in questo runtime Jupyter, devi riavviare il runtime:

   # Restart kernel after installs so that your environment can access the new packages
   import IPython
   
   app = IPython.Application.instance()
   app.kernel.do_shutdown(True)
   

7. Imposta le seguenti variabili di ambiente, sostituendo PROJECT_ID con il tuo ID progetto.

   # set project ID and location
   PROJECT_ID = "PROJECT_ID"
   LOCATION = "us-central1"
   
   # generate a unique id for this session
   from datetime import datetime
   UID = datetime.now().strftime("%m%d%H%M")
   

Abilita le API

Nel tuo blocco note Jupyterlab, esegui questo comando per abilitare le API per Compute Engine, Vertex AI e Cloud Storage nel blocco note:

! gcloud services enable compute.googleapis.com aiplatform.googleapis.com storage.googleapis.com \
  --project {PROJECT_ID}

prepara i dati di esempio in un bucket Cloud Storage

In questo tutorial viene utilizzato lo stesso set di dati TheLook utilizzato nella guida rapida di Vector Search. Per saperne di più su questo set di dati, consulta la pagina della documentazione della guida rapida.

In questa sezione creerai un bucket Cloud Storage e posizionerai al suo interno il file di incorporamento del set di dati. In un passaggio successivo, utilizzerai questo file per creare un indice.

1. Nel tuo blocco note Jupyterlab, crea un bucket Cloud Storage:

   BUCKET_URI = f"gs://{PROJECT_ID}-vs-quickstart-{UID}"
   ! gsutil mb -l $LOCATION -p $PROJECT_ID $BUCKET_URI
   

2. Copia il file di esempio nel bucket Cloud Storage.

   ! gsutil cp "gs://github-repo/data/vs-quickstart/product-embs.json" $BUCKET_URI
   

3. Per utilizzare Vector Search per eseguire query, devi anche copiare il file di incorporamento in una directory locale:

   ! gsutil cp "gs://github-repo/data/vs-quickstart/product-embs.json" . # for query tests
   

Crea l'indice di Vector Search

1. Nel tuo blocco note Jupyterlab, carica gli incorporamenti in Vector Search:

   # init the aiplatform package
   from google.cloud import aiplatform
   aiplatform.init(project=PROJECT_ID, location=LOCATION)
   

2. Crea un MatchingEngineIndex con la sua funzione create_tree_ah_index (Matching Engine è il nome precedente di Vector Search):

   # create Index
   my_index = aiplatform.MatchingEngineIndex.create_tree_ah_index(
     display_name = f"vs-quickstart-index-{UID}",
     contents_delta_uri = BUCKET_URI,
     dimensions = 768,
     approximate_neighbors_count = 10,
   )
   

   Il metodo MatchingEngineIndex.create_tree_ah_index() crea un indice. In questo tutorial, questa attività richiede circa 5-10 minuti.

3. Nella console Google Cloud, vai alla scheda Indici nella pagina Vector Search.

   Vai a Indici

4. Verifica che esista un indice il cui nome inizi con "vs-quickstart-index-" e contenga il timestamp corretto.

5. Prendi nota dell'ID indice. Questo ID ti servirà quando eseguirai il deployment dell'indice in un passaggio successivo.

Crea l'endpoint indice

1. In Cloud Shell, esegui questi comandi, sostituendo PROJECT_ID con il tuo ID progetto:

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   SERVICE_PROJECT=${projectid}
   REGION=us-central1
   VERTEX_ENDPOINT=$REGION-aiplatform.googleapis.com
   DISPLAY_NAME=vector-search
   

2. Crea l'endpoint indice:

   curl -H "Content-Type: application/json" \
     -H "Authorization: Bearer `gcloud auth print-access-token`" \
     http://$VERTEX_ENDPOINT/v1/projects/$SERVICE_PROJECT/locations/$REGION/indexEndpoints \
     -d '{displayName: "'$DISPLAY_NAME'", privateServiceConnectConfig: { enablePrivateServiceConnect: true, projectAllowlist: ["'$SERVICE_PROJECT'"] }}'
   

3. Verifica che l'endpoint indice sia stato creato:

   gcloud ai index-endpoints list --region=us-central1
   

   Dovresti vedere un output simile all'esempio seguente, in cui l'ID endpoint indice è 8151506529447575552:

   Using endpoint [http://us-central1-aiplatform.googleapis.com/]
   ---
   createTime: '2023-10-10T23:55:20.526145Z'
   displayName: vector-search
   encryptionSpec: {}
   etag: AMEw9yN2qytNiwT73uwYpz_7N_b2-O8D1AuNoDb5QjFmkU4ye5Gzk2oQlMZBR1XeoQ11
   name: projects/725264228516/locations/us-central1/indexEndpoints/8151506529447575552
   privateServiceConnectConfig:
     enablePrivateServiceConnect: true
     projectAllowlist:
     - vertex-genai-400103
     - vertex-genai-400103
   updateTime: '2023-10-10T23:55:21.951394Z'
   

4. Prendi nota dell'ID dell'endpoint indice. Questo ID ti servirà per il deployment dell'indice in un passaggio successivo.

esegui il deployment dell'indice nell'endpoint

In Cloud Shell, esegui questo comando per eseguire il deployment dell'indice nell'endpoint:

gcloud ai index-endpoints deploy-index INDEX_ENDPOINT_ID \
  --deployed-index-id=vector_one \
  --display-name=vector-search \
  --index=INDEX \
  --project=$projectid \
  --region=us-central1

Sostituisci i seguenti valori:

• INDEX_ENDPOINT_ID: l'ID dell'endpoint indice per l'endpoint indice di Private Service Connect che hai creato
• INDEX: l'ID per l'indice di cui stai eseguendo il deployment

Dovresti vedere un output simile all'esempio seguente, in cui l'ID dell'endpoint indice è 8151506529447575552:

Using endpoint [http://us-central1-aiplatform.googleapis.com/]
The deploy index operation [projects/725264228516/locations/us-central1/indexEndpoints/8151506529447575552/operations/6271807495283408896] was submitted successfully.

Quando esegui il deployment dell'indice, viene generato un endpoint Private Service Connect. L'operazione di deployment richiede da 10 a 15 minuti.

Verifica che il deployment dell'indice sia stato eseguito nell'endpoint indice

1. Nella console Google Cloud, vai alla scheda Endpoint indice nella pagina Vector Search.

   Vai a Endpoint indice

2. Verifica che l'endpoint indice vector-search abbia un indice di cui è stato eseguito il deployment chiamato anche vector-search.

   Se accanto al nome dell'endpoint dell'indice viene visualizzato un cerchio blu rotante, significa che il deployment dell'indice è ancora in corso.

Recupera l'URI del collegamento al servizio per l'endpoint indice

Una volta completato il deployment dell'indice, potrai ottenere l'URI del collegamento al servizio.

In Cloud Shell, esegui questo comando per ottenere l'URI della connessione del servizio per l'endpoint Private Service Connect:

gcloud ai index-endpoints list --region=us-central1 | grep -i  serviceAttachment:

Nell'output di esempio seguente, l'URI del collegamento al servizio è projects/je84d1de50cd8bddb-tp/regions/us-central1/serviceAttachments/sa-gkedpm-527af280e65971fd786aaf6163e798.

Using endpoint [http://us-central1-aiplatform.googleapis.com/]
 serviceAttachment: projects/je84d1de50cd8bddb-tp/regions/us-central1/serviceAttachments/sa-gkedpm-527af280e65971fd786aaf6163e798

Annota l'URI serviceAttachment, che inizia con projects, ad esempio projects/je84d1de50cd8bddb-tp/regions/us-central1/serviceAttachments/sa-gkedpm-527af280e65971fd786aaf6163e798. Ti servirà nel passaggio successivo, quando creerai un endpoint consumer.

Crea l'endpoint consumer Private Service Connect

1. In Cloud Shell, prenota un indirizzo IP dell'endpoint del consumer che verrà utilizzato per eseguire query sull'indice di Vector Search:

   gcloud compute addresses create vector-search-endpoint1 \
     --region=us-central1 \
     --subnet=consumer-endpoint-subnet
   

2. Trova l'indirizzo IP riservato:

   gcloud compute addresses list --filter="name=vector-search-endpoint1"
   

3. Crea una regola di forwarding per connettere l'endpoint al collegamento al servizio, sostituendo SERVICE_ATTACHMENT_URI con l'URI serviceAttachment.

   gcloud compute forwarding-rules create vector-search-endpoint1 \
     --region=us-central1 \
     --network=vertex-networking-vpc \
     --address=vector-search-endpoint1 \
     --target-service-attachment=SERVICE_ATTACHMENT_URI
   

   Di seguito è riportato un esempio di utilizzo di questo comando:

   gcloud compute forwarding-rules create vector-search-endpoint1 \
     --region=us-central1 \
     --network=vertex-networking-vpc \
     --address=vector-search-endpoint1 \
     --target-service-attachment=projects/je84d1de50cd8bddb-tp/regions/us-central1/serviceAttachments/sa-gkedpm-527af280e65971fd786aaf6163e798
   

4. Nella console Google Cloud, vai alla scheda Endpoint connessi nella pagina Private Service Connect.

   Vai a Endpoint connessi

5. Verifica che lo stato dell'endpoint del consumer sia Accepted.

6. Prendi nota dell'indirizzo IP dell'endpoint consumer Private Service Connect. In un passaggio successivo, utilizzerai questo endpoint per stabilire la comunicazione con l'indice Vector Search di cui è stato eseguito il deployment.

Esegui una query sull'indice di cui è stato eseguito il deployment

Ora che hai stabilito un endpoint consumer Private Service Connect collegato al tuo endpoint indice di Vector Search, puoi eseguire query sull'indice di cui hai eseguito il deployment inviando le query dall'istanza VM on-prem-client all'endpoint consumer.

Per consentire a Identity-Aware Proxy (IAP) di connettersi alle tue istanze VM, puoi creare una regola firewall che:

• Si applica a tutte le istanze VM che vuoi rendere accessibili tramite IAP.
• Consente il traffico TCP attraverso la porta 22 dell'intervallo IP 35.235.240.0/20. Questo intervallo contiene tutti gli indirizzi IP che IAP utilizza per l'inoltro TCP.

Dopo aver creato il firewall, installerai il client gRPC. In un passaggio successivo, utilizzerai il client gRPC per inviare query dall'istanza VM on-prem-client.

Crea la regola firewall e installa gRPC

1. In Cloud Shell, esegui questi comandi, sostituendo PROJECT_ID con il tuo ID progetto:

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

2. Crea una regola firewall IAP denominata ssh-iap-vpc:

   gcloud compute firewall-rules create ssh-iap-vpc \
     --network onprem-vpc \
     --allow tcp:22 \
     --source-ranges=35.235.240.0/20
   

3. Accedi all'istanza VM on-prem-client:

   gcloud compute ssh on-prem-client \
     --project=$projectid \
     --zone=us-central1-a \
     --tunnel-through-iap
   

4. Nell'istanza VM on-prem-client, installa il client gRPC:

   sudo apt-get install git -y
   git clone http://github.com/grpc/grpc.git
   sudo apt-get install build-essential autoconf libtool pkg-config -y
   sudo apt-get install cmake -y
   cd grpc/
   git submodule update --init
   mkdir -p cmake/build
   cd cmake/build
   cmake -DgRPC_BUILD_TESTS=ON ../..
   make grpc_cli
   

   L'installazione richiede circa 30 minuti.

Recupera un ID per un elemento di indice esistente

1. Nella console Google Cloud, vai alla scheda Istanze nella pagina Vertex AI Workbench.

   Vai a Vertex AI Workbench

2. Accanto al nome dell'istanza di Vertex AI Workbench, fai clic su Apri JupyterLab.

   L'istanza di Vertex AI Workbench apre JupyterLab.

3. Seleziona File > Nuovo > Terminale.

4. Nel terminale JupyterLab (non in Cloud Shell), visualizza l'ultima voce dell'indice:

   tail -1 product-embs.json
   

5. Cerca la prima coppia chiave-valore nell'elemento, contenente il relativo numero ID, come nell'esempio riportato di seguito:

   "id":"27452"
   

   Prendi nota di questo numero. Lo utilizzerai nella sezione successiva.

Eseguire una query di ricerca vettoriale

Nell'istanza VM on-prem-client, esegui una query sull'indice di cui hai eseguito il deployment:

./grpc_cli call  CONSUMER_ENDPOINT_IP:10000  google.cloud.aiplatform.container.v1.MatchService.Match "deployed_index_id:'"vector_one"',embedding_id: '"ITEM_ID"'"

Sostituisci i seguenti valori:

• CONSUMER_ENDPOINT_IP: indirizzo IP dell'endpoint consumer Private Service Connect che hai creato nella sezione precedente
• ITEM_ID: il numero dell'ID articolo salvato nella sezione precedente

L'output dovrebbe essere simile all'esempio seguente:

   user@on-prem-client:~/grpc/cmake/build$ ./grpc_cli call  172.16.30.2:10000  google.cloud.aiplatform.container.v1.MatchService.Match "deployed_index_id:'"vector_one"',embedding_id: '"20020916"'" 
   connecting to 172.16.30.2:10000
   neighbor {
     id: "16136217"
     distance: 0.99999558925628662
   }
   neighbor {
     id: "2196405"
     distance: 0.82817935943603516
   }
   neighbor {
     id: "3796353"
     distance: 0.82687419652938843
   }
   neighbor {
     id: "815154"
     distance: 0.8179466724395752
   }
   neighbor {
     id: "16262338"
     distance: 0.816785454750061
   }
   neighbor {
     id: "31290454"
     distance: 0.81560027599334717
   }
   neighbor {
     id: "4012943"
     distance: 0.80958610773086548
   }
   neighbor {
     id: "39738359"
     distance: 0.8020891547203064
   }
   neighbor {
     id: "7691697"
     distance: 0.80035769939422607
   }
   neighbor {
     id: "6398888"
     distance: 0.79880392551422119
   }
   Rpc succeeded with OK status