Questa pagina è stata tradotta dall'API Cloud Translation.

Utilizzare Private Service Connect per accedere a un indice di ricerca di vettori on-premise

Gli host on-premise possono raggiungere un endpoint dell'indice di ricerca vettoriale tramite internet pubblico o in privato tramite un'architettura di rete ibrida che utilizza Private Service Connect su Cloud VPN o Cloud Interconnect. Entrambe le opzioni offrono la crittografia SSL/TLS. Tuttavia, l'opzione privata offre prestazioni molto migliori ed è quindi consigliata per le applicazioni critiche.

In questo tutorial, utilizzi la VPN ad alta disponibilità per accedere privatamente a un endpoint dell'indice di ricerca vettoriale tra due reti Virtual Private Cloud (VPC) che possono fungere da base per la connettività privata multicloud e on-premise.

Questo tutorial è destinato ad amministratori di rete aziendali, data scientist e ricercatori che hanno familiarità con Vertex AI, Virtual Private Cloud, la console Google Cloud e Cloud Shell. Suggeriamo, ma non è obbligatoria, esperienza con la ricerca vettoriale.

Obiettivi

Crea due reti VPC, come mostrato nel diagramma precedente:
- Un (onprem-vpc) rappresenta una rete on-premise.
- L'altro (vertex-networking-vpc) è per l'endpoint indice di Vector Search.
Esegui il deployment di gateway VPN ad alta disponibilità, tunnel Cloud VPN e router Cloud per connettere vertex-networking-vpc e onprem-vpc.
Crea ed esegui il deployment di un indice Vector Search.
Crea una regola di forwarding di Private Service Connect per inoltrare le query all'endpoint dell'indice Vector Search.
Configura una route annunciata personalizzata del router Cloud in vertex-networking-vpc per annunciare le route per l'endpoint dell'indice a onprem-vpc.
Crea un'istanza VM di Compute Engine in onprem-vpc per rappresentare un'applicazione client che invia richieste all'endpoint dell'indice di ricerca vettoriale tramite la VPN ad alta disponibilità.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova senza costi.

Al termine delle attività descritte in questo documento, puoi evitare l'addebito di ulteriori costi eliminando le risorse che hai creato. Per ulteriori informazioni, vedi Pulizia.

Prima di iniziare

In the Google Cloud console, go to the project selector page.

Go to project selector
Select or create a Google Cloud project.
Roles required to select or create a project
- Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
- Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
Verify that billing is enabled for your Google Cloud project.
Apri Cloud Shell per eseguire i comandi elencati in questo tutorial. Cloud Shell è un ambiente shell interattivo per Google Cloud che ti consente di gestire progetti e risorse dal browser web.
In Cloud Shell, imposta il progetto corrente sul tuo Google Cloud ID progetto e memorizza lo stesso ID progetto nella variabile di shell projectid:
```
  projectid="PROJECT_ID"
  gcloud config set project ${projectid}
```
Sostituisci PROJECT_ID con l'ID progetto. Se necessario, puoi trovare l'ID progetto nella Google Cloud console. Per saperne di più, consulta Trovare l'ID progetto.
Se non sei il proprietario del progetto, chiedi al proprietario del progetto di concederti il ruolo Amministratore IAM progetto (roles/resourcemanager.projectIamAdmin). Devi disporre di questo ruolo per concedere i ruoli IAM nel passaggio successivo.
Make sure that you have the following role or roles on the project: roles/aiplatform.user, roles/compute.instanceAdmin.v1, roles/compute.networkAdmin, roles/compute.securityAdmin, roles/dns.admin, roles/iam.serviceAccountAdmin, roles/iam.serviceAccountUser, roles/iap.admin, roles/iap.tunnelResourceAccessor, roles/notebooks.admin, roles/servicemanagement.quotaAdmin, roles/servicedirectory.editor, roles/storage.admin, roles/aiplatform.admin, roles/aiplatform.user, roles/resourcemanager.projectIamAdmin
Check for the roles
1. In the Google Cloud console, go to the IAM page.
  Go to IAM
2. Select the project.
3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.
4. For all rows that specify or include you, check the Role column to see whether the list of roles includes the required roles.
Grant the roles
1. In the Google Cloud console, go to the IAM page.
  Vai a IAM
2. Seleziona il progetto.
3. Fai clic su Concedi l'accesso.
4. Nel campo Nuove entità, inserisci il tuo identificatore dell'utente. In genere si tratta dell'indirizzo email di un Account Google.
5. Nell'elenco Seleziona un ruolo, seleziona un ruolo.
6. Per concedere altri ruoli, fai clic su Aggiungi un altro ruolo e aggiungi ogni ruolo aggiuntivo.
7. Fai clic su Salva.
Enable the DNS, IAM, Compute Engine, Notebooks, and Vertex AI APIs.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.
Enable the APIs

Crea le reti VPC

In questa sezione creerai due reti VPC: una per creare un indice di ricerca vettoriale e distribuirlo a un endpoint, l'altra per l'accesso privato a quell'endpoint.

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

Crea la rete VPC per l'endpoint indice:

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

Crea una subnet denominata workbench-subnet con un intervallo IPv4 primario di 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

Crea una subnet denominata psc-forwarding-rule-subnet, con un intervallo IPv4 primario di 172.16.30.0/28:

gcloud compute networks subnets create psc-forwarding-rule-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`)

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

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

Nella rete onprem-vpc, crea una subnet denominata onprem-vpc-subnet1, con un intervallo IPv4 principale di 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

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

Vai a Reti VPC
Nell'elenco delle reti VPC, verifica che siano state create le due reti: vertex-networking-vpc e onprem-vpc.
Fai clic sulla scheda Subnet nel progetto attuale.
Nell'elenco delle subnet VPC, verifica che siano state create le subnet workbench-subnet, psc-forwarding-rule-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 indice di Vector Search tramiteVPN ad alta disponibilitàPN.

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=https://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 crei due gateway VPN ad alta disponibilità connessi tra loro. Una 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à

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

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

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

Vai alla VPN
Verifica che i due gateway (vertex-networking-vpn-gw1 e onprem-vpn-gw1) siano stati creati e che ognuno 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 regionale. In ognuno dei router Cloud regionali, crei un gateway Cloud NAT. I gateway Cloud NAT forniscono connettività in uscita per le istanze di macchine virtuali (VM) Compute Engine che non dispongono di indirizzi IP esterni.

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

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

Crea un router Cloud regionale per la rete VPC vertex-networking-vpc:

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

Configura un gateway Cloud NAT sul router Cloud regionale:

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

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

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

Configura un gateway Cloud NAT sul router Cloud regionale:

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

Nella Google Cloud console, vai alla pagina Cloud Router.

Vai a Router Cloud
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
Potresti dover aggiornare la scheda del browser della console Google Cloud per visualizzare i nuovi valori.
Nell'elenco dei router Cloud, fai clic su cloud-router-us-central1-vertex-nat.
Nella pagina Dettagli router, verifica che sia stato creato il gateway Cloud NAT cloud-nat-us-central1.
Fai clic sulla freccia indietro per tornare alla pagina Router Cloud.
Nell'elenco dei router, fai clic su cloud-router-us-central1-onprem-nat.
Nella pagina Dettagli router, verifica che sia stato creato il gateway Cloud NAT cloud-nat-us-central1-on-prem.

Crea tunnel VPN

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

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

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

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

Nella console Google Cloud , vai alla pagina VPN.

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

Definizione di sessioni BGP

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). Su Cloud Router, configuri un'interfaccia e un peer BGP per il tuo router on-premise. L'abbinamento dell'interfaccia e della configurazione peer BGP crea 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.

Definisci sessioni BGP per `vertex-networking-vpc`

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

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

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

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

Definisci sessioni BGP per `onprem-vpc`

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

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

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

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 della sessione BGP

Nella console Google Cloud , vai alla pagina VPN.

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

Convalida le route apprese `vertex-networking-vpc`

Nella console Google Cloud , vai alla pagina Reti VPC.

Vai a Reti VPC
Nell'elenco delle reti VPC, fai clic su vertex-networking-vpc.
Fai clic sulla scheda Percorsi.
Seleziona us-central1 (Iowa) nell'elenco Regione e fai clic su Visualizza.
Nella colonna Intervallo IP di destinazione, verifica che l'intervallo IP della subnet onprem-vpc-subnet1 (172.16.10.0/29) venga visualizzato due volte.

Convalida le route apprese `on-prem-vpc`

Fai clic sulla Freccia indietro per tornare alla pagina Reti VPC.
Nell'elenco delle reti VPC, fai clic su on-prem-vpc.
Fai clic sulla scheda Percorsi.
Seleziona us-central1 (Iowa) nell'elenco Regione e fai clic su Visualizza.
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 psc-forwarding-rule-subnet (172.16.30.0/28) vengano visualizzati due volte ciascuno.

crea un'istanza di Vertex AI Workbench

In questa sezione crei un account di servizio gestito dall'utente, quindi crei un'istanza di Vertex AI Workbench che utilizza il tuoaccount di serviziot per accedere a servizi e APIGoogle Cloud .

Crea un account di servizio

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

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

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

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

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

Assegna il ruolo IAM Storage Admin (roles/storage.admin) al account di servizio:

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

Assegna il ruolo IAM Amministratore utilizzo servizi (roles/serviceusage.serviceUsageAdmin) al 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 il 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 Vector Search

prepara l'ambiente

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

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

L'istanza di Vertex AI Workbench apre JupyterLab.
Seleziona File > Nuovo > Blocco note.
Nel menu Seleziona kernel, seleziona Python 3 (locale) e fai clic su Seleziona.
Quando si apre il nuovo notebook, è presente una cella di codice predefinita in cui puoi inserire il codice. Sembra che ci sia [ ]: seguito da un campo di testo. Il campo di testo è il punto in cui incollare il codice.

Per installare l'SDK Vertex AI Python, incolla il seguente codice nella cella e fai clic su Esegui le celle selezionate e vai avanti:
```
!pip install --upgrade --user google-cloud-aiplatform google-cloud-storage
```
In questo passaggio e in ognuno dei seguenti, aggiungi una nuova cella di codice (se necessario) facendo clic su Inserisci una cella sotto, incolla il codice nella cella e poi fai clic su Esegui le celle selezionate e vai avanti.

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

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 API

Nel notebook JupyterLab, esegui il comando seguente per abilitare le API per Compute Engine, Vertex AI e Cloud Storage nel notebook:

! 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, utilizziamo lo stesso set di dati TheLook utilizzato nella guida rapida alla ricerca vettoriale. Per saperne di più su questo set di dati, consulta la pagina della documentazione della guida rapida.

In questa sezione crei un bucket Cloud Storage e inserisci il file di incorporamento del set di dati. In un passaggio successivo, utilizzerai questo file per creare un indice.

Nel notebook JupyterLab, crea un bucket Cloud Storage:

BUCKET_URI = f"gs://{PROJECT_ID}-vs-quickstart-{UID}"
! gcloud storage buckets create $BUCKET_URI --location=$LOCATION --project=$PROJECT_ID

Copia il file di esempio nel tuo bucket Cloud Storage.

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

Per utilizzare la ricerca vettoriale per eseguire query, devi anche copiare il file di incorporamento in una directory locale:
```
! gcloud storage cp "gs://github-repo/data/vs-quickstart/product-embs.json" . # for query tests
```

Crea l'indice Vector Search

Nel blocco note JupyterLab, carica gli incorporamenti in Ricerca vettoriale:

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

Crea un MatchingEngineIndex con la relativa funzione create_tree_ah_index (Matching Engine è il nome precedente di Ricerca vettoriale):
```
# 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.
Nella console Google Cloud , vai alla scheda Indici nella pagina Vector Search.

Vai a Indici
Verifica che esista un indice il cui nome inizia con "vs-quickstart-index-" e contenga il timestamp corretto.
Prendi nota dell'ID indice. Avrai bisogno di questo ID quando implementerai l'indice in un passaggio successivo.

Crea l'endpoint indice

In Cloud Shell, esegui i comandi seguenti, 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

Crea l'endpoint dell'indice:

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

Verifica che l'endpoint indice sia stato creato:

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

L'output è simile al seguente esempio, in cui l'ID endpoint dell'indice è 8151506529447575552:

Using endpoint [https://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'

Prendi nota dell'ID endpoint indice. Ti servirà quando implementerai l'indice in un passaggio successivo.

Esegui il deployment dell'indice sull'endpoint

In Cloud Shell, esegui questo comando per eseguire il deployment dell'indice all'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 endpoint indice per l'endpoint indice Private Service Connect che hai creato
INDEX: l'ID dell'indice che stai eseguendo il deployment

L'output è simile al seguente esempio, in cui l'ID endpoint dell'indice è 8151506529447575552:

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

L'operazione di deployment richiede circa 10-15 minuti. Quando esegui il deployment dell'indice, viene generato un collegamento al servizio.

Verifica che l'indice sia stato sottoposto a deployment nell'endpoint dell'indice

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

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

Se accanto al nome dell'endpoint indice viene visualizzato un cerchio blu che gira, l'indice è ancora in fase di deployment.

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

Una volta eseguito il deployment completo dell'indice, puoi ottenere l'URI dell'allegato di servizio.

In Cloud Shell, esegui questo comando per ottenere l'URI dell'allegato di servizio:

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

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

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

Prendi nota dell'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 una regola di forwarding.

Creare una regola di forwarding

In Cloud Shell, prenota un indirizzo IP da utilizzare per la regola di forwarding per eseguire query sull'indice di ricerca vettoriale:

gcloud compute addresses create vector-search-forwarding-rule \
  --region=us-central1 \
  --subnet=psc-forwarding-rule-subnet

Trova l'indirizzo IP riservato:

gcloud compute addresses list --filter="name=vector-search-forwarding-rule"

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-forwarding-rule \
  --region=us-central1 \
  --network=vertex-networking-vpc \
  --address=vector-search-forwarding-rule \
  --target-service-attachment=SERVICE_ATTACHMENT_URI

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

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

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

Vai a Endpoint connessi
Verifica che lo stato di vector-search-forwarding-rule sia Accepted.
Prendi nota dell'indirizzo IP della regola di forwarding di Private Service Connect. In un passaggio successivo, utilizzerai questo endpoint per stabilire la comunicazione con l'indice di ricerca vettoriale di cui è stato eseguito il deployment.

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

Ora che hai stabilito una regola di forwarding Private Service Connect collegata all'endpoint dell'indice Vector Search, puoi eseguire query sull'indice di cui è stato eseguito il deployment inviando le query dall'istanza VM on-prem-client alla regola di forwarding.

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

Si applichi a tutte le istanze VM a cui vuoi accedere tramite IAP.
Consente il traffico TCP tramite la porta 22 dall'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, installa 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

In Cloud Shell, esegui i seguenti comandi, sostituendo PROJECT_ID con il tuo ID progetto:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

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

Accedi all'istanza VM on-prem-client:

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

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

sudo apt-get install git -y
git clone https://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.

Recuperare un ID per un elemento dell'indice esistente

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

Vai a Vertex AI Workbench
Fai clic su Apri JupyterLab accanto al nome dell'istanza di Vertex AI Workbench.

L'istanza di Vertex AI Workbench apre JupyterLab.
Seleziona File > Nuovo > Terminale.
Nel terminale JupyterLab (non in Cloud Shell), visualizza l'ultima voce dell'indice:
```
tail -1 product-embs.json
```
Cerca la prima coppia chiave-valore nell'elemento, che contiene il numero ID dell'elemento, come nell'esempio seguente:
```
"id":"27452"
```
Prendi nota di questo numero ID. Ti servirà per eseguire una query nella sezione successiva.

Eseguire una query di ricerca vettoriale

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

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