Accedere a Gemini Chat con l'SDK Python tramite l'endpoint Private Service Connect

1. Panoramica

È possibile accedere all'API Vertex AI tramite internet, tuttavia nella tua azienda potrebbe essere utile accedervi in privato, senza utilizzare internet. In questo lab accederai innanzitutto all'API Vertex Gemini Chat tramite l'SDK Python in esecuzione su un'istanza VM tramite la rete internet pubblica.

Quindi creerai un endpoint Private Service Connect alle API di Google e modificherai il flusso di traffico in modo da utilizzare l'endpoint privato per la connessione all'API Gemini Chat. Le configurazioni saranno una combinazione di Terraform, gcloud e console.

In questo lab creerai il seguente pattern.

Figura1.

2. Obiettivo

In questo lab imparerai a:

• Configura un'istanza VM per utilizzare l'SDK Python
• Connettiti a Gemini Chat tramite script Python
• Configura l'endpoint PSC per connetterti a Googleapis
• Verifica il percorso di connettività verso Googleais
• Configura le voci DNS manuali

Configurazione dell'ambiente da seguire in modo autonomo

1. Accedi alla console Google Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai ancora un account Gmail o Google Workspace, devi crearne uno.

• Il nome del progetto è il nome visualizzato per i partecipanti al progetto. Si tratta di una stringa di caratteri non utilizzata dalle API di Google. Puoi sempre aggiornarla.
• L'ID progetto è univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo essere stato impostato). La console Cloud genera automaticamente una stringa univoca. In genere non è importante sapere cosa sia. Nella maggior parte dei codelab, devi fare riferimento al tuo ID progetto (in genere identificato come PROJECT_ID). Se non ti piace l'ID generato, potresti generarne un altro casuale. In alternativa, puoi provarne una personalizzata per verificare se è disponibile. Non può essere modificato dopo questo passaggio e rimane invariato per tutta la durata del progetto.
• Per tua informazione, esiste un terzo valore, un Numero progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.

Attenzione:un ID progetto è univoco a livello globale e non può essere utilizzato da nessun altro utente dopo essere stato selezionato. Sei l'unico utente di quell'ID. Anche se un progetto viene eliminato, l'ID non può essere riutilizzato

Nota: se utilizzi un account Gmail, puoi lasciare l'impostazione predefinita su Nessuna organizzazione. Se utilizzi un account Google Workspace, scegli una località adatta alla tua organizzazione.

2. Successivamente, dovrai abilitare la fatturazione nella console Cloud per utilizzare risorse/API Cloud. La partecipazione a questo codelab non ha costi, o quasi. Per arrestare le risorse ed evitare di incorrere in fatturazione dopo questo tutorial, puoi eliminare le risorse che hai creato o eliminare il progetto. I nuovi utenti di Google Cloud sono idonei al programma prova senza costi di 300$.

Avvia Cloud Shell

Anche se Google Cloud può essere utilizzato da remoto dal tuo laptop, in questo codelab utilizzerai Google Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud.

Nella console Google Cloud, fai clic sull'icona di Cloud Shell nella barra degli strumenti in alto a destra:

Dovrebbe richiedere solo pochi istanti per eseguire il provisioning e connettersi all'ambiente. Al termine, dovresti vedere qualcosa di simile a questo:

Questa macchina virtuale contiene tutti gli strumenti di sviluppo di cui avrai bisogno. Offre una home directory permanente da 5 GB e viene eseguita su Google Cloud, migliorando notevolmente le prestazioni e l'autenticazione di rete. Tutto il lavoro in questo codelab può essere svolto in un browser. Non occorre installare nulla.

3. Attività 1: Configura l'ambiente con Terraform

Creeremo una VPC personalizzata con regole firewall e subnet. Apri la console Cloud e seleziona il progetto che utilizzerai.

1. Apri Cloud Shell nella parte superiore della console a destra, assicurati di vedere l'ID progetto corretto in Cloud Shell e conferma eventuali richieste per consentire l'accesso.
2. Crea una cartella denominata terraform-build e spostati nella cartella

mkdir terraform-build  && cd terraform-build

3. Crea un file main.tf e variable.tf.

touch main.tf variable.tf 

4. Passa alla visualizzazione dell'editor di Cloud Shell. Seleziona Editor e assicurati di consentire tutti i prompt necessari per consentire il caricamento dell'interfaccia.
5. Una volta caricato, vai a File > Apri cartella e vai a /home/tuo-nome-utente/terraform-build e seleziona Ok per aprire la cartella nell'editor.
6. Seleziona il file variable.tf e aggiungi quanto segue. Sostituisci il testo your-project-id-here con l'ID progetto effettivo tra virgolette.

variable "project_id" {
  type = string
  default = "your-project-id-here"
}

variable "network_id" {
  type = string
  default = "python-net"
}

7. Quindi apri il file main.tf. Aggiungeremo del codice Terraform per eseguire varie azioni come spiegato di seguito.

Abilita le API	resource "google_project_service" "default"
Crea un VPC denominato python-net	resource "google_compute_network" "default"
Aggiungi una subnet	resource "google_compute_subnetwork" "default"
Aggiungi due regole firewall	resource "google_compute_firewall" "allow_icmp"resource "google_compute_firewall" "allow_ssh"

8. Copia e incolla quanto segue nel file .tf principale.

resource "google_project_service" "default" {
  for_each = toset([
    "dns.googleapis.com",
    "aiplatform.googleapis.com",
    "servicedirectory.googleapis.com"
  ])

  service            = each.value
  disable_on_destroy = false
}

resource "google_compute_network" "default" {
  project                 = var.project_id
  name                    = var.network_id
  auto_create_subnetworks = false
  mtu                     = 1460
  routing_mode            = "GLOBAL"
}

resource "google_compute_subnetwork" "default" {
  name          = "vm1-subnet"
  ip_cidr_range = "10.0.11.0/24"
  region        = "us-east1"
  stack_type    = "IPV4_ONLY"
  network       = google_compute_network.default.id
}

resource "google_compute_firewall" "allow_icmp" {
  name    = "allow-icmp-${google_compute_network.default.name}"
  network = google_compute_network.default.id
  project = var.project_id

  allow {
    protocol = "icmp"
  }

  source_ranges = ["0.0.0.0/0"]
  target_tags   = ["allow-icmp"]
}

resource "google_compute_firewall" "allow_ssh" {
  name    = "allow-ssh-${google_compute_network.default.name}"
  network = google_compute_network.default.id
  project = var.project_id

  allow {
    protocol = "tcp"
    ports    = ["22"]
  }

  source_ranges = ["0.0.0.0/0"]
  target_tags   = ["allow-ssh"]
}

9. Torna al terminal Cloud Shell, assicurati di trovarti nella directory terraform-build cd terraform-build ed esegui i seguenti comandi

terraform init

Inizializza la directory di lavoro. Questo passaggio consente di scaricare i provider richiesti per la configurazione specificata.

terraform plan

Genera un piano di esecuzione che mostra le azioni che Terraform eseguirà per eseguire il deployment dell'infrastruttura.

10. Ora, per creare le risorse, esegui il comando terraform apply e digita yes per eseguirlo.

Verifica la configurazione: controlla il tuo ambiente per verificare che:

1 VPC denominata python-net

1 subnet

2 firewall-rules

4. Attività 2: Crea gateway NAT e VM con Terraform

Dobbiamo concedere l'accesso esterno in uscita a internet, quindi creiamo un gateway Cloud NAT e agganciamolo.

1. Apri Cloud Shell, passa alla cartella terraform-build e crea i file seguenti (in totale tre file). Le modificheremo in seguito.

touch nat-vm.tf psc.tf dns.tf

2. Passa alla visualizzazione dell'editor Cloud Shell, seleziona il file nat-vm.tf e aggiungi il seguente codice Terraform. Verranno creati un gateway NAT e due VM.

Terraform nat-vm.tf

resource "google_compute_router" "default" {
  name    = "py-outbound-nat"
  region  = "us-east1"
  network = google_compute_network.default.id

 bgp {
  asn = 64514
  }
}

resource "google_compute_router_nat" "default" {
  name                               = "py-outbound-nat-gw"
  router                             = google_compute_router.default.name
  region                             = google_compute_router.default.region
  nat_ip_allocate_option             = "AUTO_ONLY"
  source_subnetwork_ip_ranges_to_nat = "ALL_SUBNETWORKS_ALL_IP_RANGES"

  log_config {
    enable = true
    filter = "ERRORS_ONLY"
  }
}

resource "google_compute_instance" "vm1" {
  name         = "py-vm1"
  zone         = "us-east1-b"
  machine_type = "n2-standard-2"

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-11"
    }
  }

  network_interface {
    subnetwork = google_compute_subnetwork.default.id  
    stack_type = "IPV4_ONLY"
  }

  tags = ["allow-ssh", "allow-icmp"]

  metadata_startup_script = <<-EOF
    sudo apt-get update
    sudo apt-get install python3 python3-dev python3-venv -y
    sudo apt-get install tcpdump dnsutils -y
    sudo -i
    sudo mkdir -p ~/py-gem-env
    cd ~/py-gem-env
    python3 -m venv env
    source env/bin/activate
    pip install ipython google-cloud-aiplatform
  EOF
}

resource "google_compute_instance" "vm2" {
  name         = "py-vm2"
  zone         = "us-east1-b"
  machine_type = "n2-standard-2"

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-11"
    }
  }

  network_interface {
    subnetwork = google_compute_subnetwork.default.id   
    stack_type = "IPV4_ONLY"
  }

  tags = ["allow-ssh", "allow-icmp"]

  metadata_startup_script = <<-EOF
    sudo apt-get update
    sudo apt-get install python3 python3-dev python3-venv -y
    sudo apt-get install tcpdump dnsutils -y
    sudo -i
    sudo mkdir -p ~/py-gem-env
    cd ~/py-gem-env
    python3 -m venv env
    source env/bin/activate
    pip install ipython google-cloud-aiplatform
  EOF
}

3. Passa al terminale Cloud Shell, assicurati di essere nella cartella terraform-build ed esegui terraform plan. In questo modo vedrai che verranno aggiunti 4 elementi, quindi esegui terraform apply e digita yes per creare il gateway NAT e due VM.

Verifica la configurazione: controlla il tuo ambiente per verificare che:

1 gateway NAT

1 router Cloud

VM denominata py-vm1

VM denominata py-vm2

5. Attività 3: Configura le VM e testa

1. Accedere alle istanze VM. Seleziona la VM che inizia con py-vm1. Seleziona SSH.
2. Dopo aver eseguito l'accesso SSH a py-vm1,abilita root digitando sudo -i
3. Attiva l'ambiente venv:

cd py-gem-env
source env/bin/activate

4. Ora eseguiamo l'autenticazione per eseguire alcuni test in un secondo momento. Esegui il comando seguente nella VM e premi y quando richiesto.

gcloud auth application-default login

5. Quindi copia l'URL che appare all'inizio con https://, apri una nuova scheda nella finestra del browser del lab e incolla l'URL. Accetta i prompt.
6. Quando viene visualizzato il codice di selezione seguente, torna alla sessione della macchina virtuale py-vm1 e, per Inserisci codice di autorizzazione, incolla il codice che hai copiato e premi Invio per autenticarti.

7. Ora eseguiamo un rapido test per verificare se possiamo connetterci all'API Vertex Gemini, che utilizza us-central1-aiplatform.googleapis.com, quindi eseguiamo un dig a quell'indirizzo per vedere come viene indirizzato il traffico.

dig us-central1-aiplatform.googleapis.com

8. Dovresti vedere qualcosa di simile (l'indirizzo sarà diverso). Tieni presente che il percorso avviene tramite indirizzi IP pubblici poiché l'API è un'API pubblica. NON COPIARE

; <<>> DiG 9.16.48-Debian <<>> us-central1-aiplatform.googleapis.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 9117
;; flags: qr rd ra; QUERY: 1, ANSWER: 16, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 512
;; QUESTION SECTION:
;us-central1-aiplatform.googleapis.com. IN A

;; ANSWER SECTION:
us-central1-aiplatform.googleapis.com. 300 IN A 173.194.210.95
us-central1-aiplatform.googleapis.com. 300 IN A 173.194.211.95
us-central1-aiplatform.googleapis.com. 300 IN A 173.194.212.95
us-central1-aiplatform.googleapis.com. 300 IN A 173.194.213.95
us-central1-aiplatform.googleapis.com. 300 IN A 173.194.215.95
us-central1-aiplatform.googleapis.com. 300 IN A 173.194.216.95
us-central1-aiplatform.googleapis.com. 300 IN A 108.177.12.95
us-central1-aiplatform.googleapis.com. 300 IN A 108.177.13.95
us-central1-aiplatform.googleapis.com. 300 IN A 74.125.26.95

9. Ora utilizziamo Python. Digita ipython per attivare l'interfaccia ipython.

ipython

10. Ora copia e incolla quanto segue. Viene chiesto a Gemini "Quali sono tutti i colori del logo di Google" e "Qual è il colore del cielo". Sostituisci enter-your-project-id-here con l'ID del progetto tra virgolette

import vertexai
from vertexai.generative_models import GenerativeModel, ChatSession

project_id = "enter-your-project-id-here" 
location = "us-central1" 

vertexai.init(project=project_id, location=location)
model = GenerativeModel("gemini-1.5-pro")
chat_session = model.start_chat()  

def get_chat_response(chat: ChatSession, prompt: str) -> str:
    text_response = []
    responses = chat.send_message(prompt, stream=True)
    for chunk in responses:
        text_response.append(chunk.text)
    return "".join(text_response)

prompt = "Hello."
print(get_chat_response(chat_session, prompt)) 

prompt = "What are all the colors of the Google logo?"
print(get_chat_response(chat_session, prompt)) 

prompt = "What color is the sky?"
print(get_chat_response(chat_session, prompt))

11. Premi Invio per eseguire e visualizzare il risultato.
12. Questa richiesta ha eseguito l'accesso a Vertex tramite l'API pubblica.
13. Chiudi la sessione SSH e continuiamo.

Nota: puoi modificare la domanda del prompt in un'altra.

Ora configura py-vm2 con le stesse configurazioni

14. Accedi alle istanze VM. Seleziona la VM che inizia con py-vm2. Scegli SSH.
15. Dopo aver eseguito l'accesso SSH a py-vm2-****, abilita il ruolo root digitando **sudo -i**
16. Attiva il tuo ambiente Venv:

cd py-gem-env
source env/bin/activate

17. Ora autentichiamoci per eseguire alcuni test in un secondo momento. Esegui questo comando nella VM

gcloud auth application-default login

18. Poi copia l'URL visualizzato all'inizio con https://, apri una nuova scheda nella finestra del browser del lab e incolla l'URL. Accetta le richieste.
19. Quando viene visualizzato il seguente messaggio, seleziona Copia, torna alla sessione della VM py-vm2 e in Inserisci codice di autorizzazione incolla il codice che hai copiato e premi Invio per autenticarti.

20. Ora eseguiamo un breve test per verificare se possiamo connetterci all'API Vertex Gemini. Questo comando utilizzerà 4 ping a us-central1-aiplatform.googleapis.com, quindi riceveremo una risposta dall'indirizzo pubblico dell'API.

ping -c 4 us-central1-aiplatform.googleapis.com

21. Torneremo per testare questa VM in un secondo momento. Chiudi la sessione SSH e continuiamo.

6. Attività 4: Crea l'endpoint PSC in googleapis con Terraform

Per abilitare la connettività privata al nostro endpoint API Vertex, creeremo un endpoint Private Service Connect per le API di Google. In questo modo potremo utilizzare un indirizzo IP privato che assegneremo per instradare il traffico alle API di Google di cui abbiamo bisogno, in questo caso Vertex.

1. Apri Cloud Shell nella visualizzazione dell'editor, se non è già aperto. Creeremo quanto segue:

• Crea un indirizzo IP per l'endpoint PSC 192.168.255.250 (resource "google_compute_global_address" "default")
• Crea un endpoint PSC per le API di Google (resource "google_compute_global_forwarding_rule" "default")

Apri il file psc.tf nella cartella terraform-build. Aggiungi il seguente codice al file.

Terraform psc.tf

resource "google_compute_global_address" "default" {
  name         = "vertex-ip"
  purpose      = "PRIVATE_SERVICE_CONNECT"
  network      = google_compute_network.default.id
  address_type = "INTERNAL"
  address      = "192.168.255.250"
}

resource "google_compute_global_forwarding_rule" "default" {  
  name                  = "pscvertexgemini"
  target                = "all-apis"
  network               = google_compute_network.default.id
  ip_address            = google_compute_global_address.default.id
  load_balancing_scheme = ""
  }

2. Passa al terminal Cloud Shell e assicurati di essere nella cartella terraform-build. Quindi esegui terraform init, poi terraform plan per visualizzare l'aggiunta di due elementi,
   poi esegui terraform apply e digita yes per creare l'endpoint delle API Google per IP e PSC.
3. Verifica l'esistenza dell'endpoint

gcloud compute addresses list --filter="name=( 'vertex-ip' ...)"

gcloud compute forwarding-rules describe pscvertexgemini --global

7. Attività 5: Verifica la connettività dell'endpoint tramite indirizzo IP

Connettiamoci usando l'endpoint privato per connetterti a Gemini.

1. Vai all'istanza VM py-vm1. Seleziona SSH e accedi tramite SSH alla VM
2. Accedi all'accesso root digitando sudo -i
3. Utilizzeremo questa singola istanza solo per testare l'endpoint PSC, quindi modificheremo il file host con la seguente voce

echo 192.168.255.250 us-central1-aiplatform.googleapis.com >> /etc/hosts

cat /etc/hosts

Nota: verrà aggiunta una voce statica che mappa l'indirizzo us-central1-aiplatform.googleapis.com all'IP dell'endpoint PSC.

4. Controlla il percorso di connettività a us-central1-aiplatform.googleapis.com utilizzando il comando ping. Verrà inviato un ping all'indirizzo IP inserito nei file host. Questo è un endpoint PSC e i ping non andranno a buon fine.

ping -c 2 us-central1-aiplatform.googleapis.com

5. Torna alla console e apri un'altra istanza dell'istanza VM py-vm1. Seleziona SSH e accedi tramite SSH alla VM
6. Per ottenere l'accesso root, digita sudo -i
7. Esegui il seguente comando per visualizzare la connettività in un dump TCP

sudo tcpdump -i any port 53 -n or host us-central1-aiplatform.googleapis.com

8. Ora torna alla prima istanza SSH dell'istanza VM py-vm1
9. Attiva l'ambiente utilizzando

cd py-gem-env
source env/bin/activate

10. Ora testiamo Python. Digita ipython per attivare l'interfaccia ipython. Questa volta il traffico passerà attraverso l'endpoint PSC.

ipython

11. Ora copia e incolla quanto segue. In questo modo chiedi a Gemini "Quali sono tutti i colori del logo di Google" e "Descrivi le Cascate del Niagara". Sostituisci enter-your-project-id-here con il tuo ID progetto tra virgolette

import vertexai
from vertexai.generative_models import GenerativeModel, ChatSession

project_id = "enter-your-project-id-here" 
location = "us-central1" 

vertexai.init(project=project_id, location=location)
model = GenerativeModel("gemini-1.5-pro")
chat_session = model.start_chat()  # Corrected line

def get_chat_response(chat: ChatSession, prompt: str) -> str:
    text_response = []
    responses = chat.send_message(prompt, stream=True)
    for chunk in responses:
        text_response.append(chunk.text)
    return "".join(text_response)

prompt = "Hello."
print(get_chat_response(chat_session, prompt)) 

prompt = "What are all the colors of the Google logo?"
print(get_chat_response(chat_session, prompt)) 

prompt = "Describe Niagara Falls"
print(get_chat_response(chat_session, prompt))

12. Premi Invio per eseguire il codice e visualizzare il risultato.
13. Torna alla seconda istanza dell'istanza VM py-vm1. Dovresti vedere il risultato di TCPDUMP. Noterai In e Out gli indirizzi IP della VM e anche l'indirizzo IP dell'endpoint PSC per connettersi a us-central1-aiplatform.googleapis.com

22:21:55.032433 ens4  Out IP 10.0.11.18.57114 > 192.168.255.250.443: Flags [.], ack 8606, win 501, options [nop,nop,TS val 1797790182 ecr 2593039209], length 0
22:21:55.468285 ens4  In  IP 192.168.255.250.443 > 10.0.11.18.57114: Flags [P.], seq 8606:8991, ack 5785, win 296, options [nop,nop,TS val 2593039645 ecr 1797790182], length 385
22:21:55.468320 ens4  Out IP 10.0.11.18.57114 > 192.168.255.250.443: Flags [.], ack 8991, win 501, options [nop,nop,TS val 1797790618 ecr 2593039645], length 0

14. Chiudi tutte le sessioni SSH con l'istanza VM py-vm1

8. Attività 6: Creare una voce DNS manuale per googleapis con Terraform (facoltativo)

Puoi creare una voce DNS manuale per puntare all'endpoint PSC utilizzando il DNS privato. Ciò influirà su tutte le emittenti che assegni.

1. Vai a Servizi di rete e seleziona Cloud DNS.
2. Nelle zone dovresti vedere una zona creata automaticamente per le API Private Service Connect per Google, con directory di servizi per il tipo di zona. Può essere utilizzato per connettersi all'endpoint PSC con il formato **SERVICE-ENDPOINT.p.googleapis.com Esempio: aiplatform-pscvertexgemini.p.googleapis.com
3. In questo caso vogliamo creare manualmente una voce DNS privata. La configurazione sarà la seguente

• Crea una zona DNS privata denominata "googleapis-private" per "googleapis.com" e limitala alla rete "python-net".
• Aggiungi un record A per mappare "googleapis.com" all'indirizzo IP "192.168.255.250".
• Aggiungi un record CNAME per reindirizzare tutti i sottodomini di "googleapis.com" (ad es. www.googleapis.com) a "googleapis.com".

4. Apri Cloud Shell nella visualizzazione dell'editor, se non è già aperto. Apri il file dns.tf nella cartella terraform-build. Aggiungi al file il seguente codice.

Terraform dns.tf

resource "google_dns_managed_zone" "private_zone" {
  name        = "googleapis-private"
  dns_name    = "googleapis.com."  
  visibility  = "private"
  project     = var.project_id     

  private_visibility_config {
    networks {
      network_url = google_compute_network.default.id  
    }
  }
}

resource "google_dns_record_set" "a_record" {
  name    = "googleapis.com."  
  type    = "A"
  ttl     = 300
  managed_zone = google_dns_managed_zone.private_zone.name
  project = var.project_id    

  rrdatas = ["192.168.255.250"]
}

resource "google_dns_record_set" "cname_record" {
 name    = "*.googleapis.com."
 type    = "CNAME"
 ttl     = 300
 managed_zone = google_dns_managed_zone.private_zone.name
 project = var.project_id    

 rrdatas = ["googleapis.com."]  
}

5. Passa al terminal Cloud Shell e assicurati di essere nella cartella terraform-build. Poi esegui terraform plan per vedere quali elementi verranno aggiunti.
   Quindi esegui terraform apply e digita yes per creare la voce DNS privata.
6. Dovresti vedere una configurazione con un record A e CNAME come questo (vedi
7. Successivamente, verificheremo la connettività con queste modifiche su py-vm2

9. Attività 7: (Facoltativo) Verifica la connettività dell'endpoint tramite indirizzo IP

Connettiamoci usando l'endpoint privato per connetterti a Gemini.

Nota:non sono necessarie configurazioni manuali sulla VM.

1. Vai all'istanza VM py-vm2. Seleziona SSH e SSH nella VM
2. Per ottenere l'accesso root, digita sudo -i
3. Controlla il percorso di connettività a us-central1-aiplatform.googleapis.com utilizzando il comando ping. Verrà eseguito un ping dell'indirizzo IP nel DNS privato, il record A per googleapis. Questo IP è un endpoint PSC e i ping non andranno a buon fine.

ping -c 2 us-central1-aiplatform.googleapis.com

4. Controlla il percorso di connettività con un ping utilizzando la voce DNS creata automaticamente per le API di Google PSC con aiplatform-pscvertexgemini.p.googleapis.com. Questo punta all'indirizzo IP dell'endpoint PSC e i ping non andranno a buon fine.

ping -c 2 aiplatform-pscvertexgemini.p.googleapis.com

5. Controlla il percorso di connettività per us-central1-aiplatform.googleapis.com utilizzando il comando dig. Deve essere l'indirizzo IP dell'endpoint PSC.

dig us-central1-aiplatform.googleapis.com

6. Torna alla console e apri un'altra istanza dell'istanza VM py-vm2. Seleziona SSH e accedi tramite SSH alla VM
7. Per ottenere l'accesso root, digita sudo -i
8. Esegui il comando seguente per vedere la connettività in un dump TCP

sudo tcpdump -i any port 53 -n or host us-central1-aiplatform.googleapis.com

9. Ora torna alla prima istanza SSH dell'istanza VM py-vm2
10. Attiva l'ambiente utilizzando

cd py-gem-env
source env/bin/activate

11. Ora testiamo Python. Digita ipython per attivare l'interfaccia ipython.

ipython

12. Ora copia e incolla quanto segue. Chiedi a Gemini "Quali sono tutti i colori del logo Google" e "Quali sono due funzionalità di Gemini Pro". Sostituisci enter-your-project-id-here con l'ID del progetto tra virgolette

import vertexai
from vertexai.generative_models import GenerativeModel, ChatSession

project_id = "enter-your-project-id-here" 
location = "us-central1" 

vertexai.init(project=project_id, location=location)
model = GenerativeModel("gemini-1.5-pro")
chat_session = model.start_chat()  # Corrected line

def get_chat_response(chat: ChatSession, prompt: str) -> str:
    text_response = []
    responses = chat.send_message(prompt, stream=True)
    for chunk in responses:
        text_response.append(chunk.text)
    return "".join(text_response)

prompt = "Hello."
print(get_chat_response(chat_session, prompt)) 

prompt = "What are all the colors of the Google logo?"
print(get_chat_response(chat_session, prompt)) 

prompt = "What are two features of Gemini pro"
print(get_chat_response(chat_session, prompt))

13. Premi Invio per eseguire il codice e visualizzare il risultato.
14. Torna alla seconda istanza dell'istanza VM py-vm2. Dovresti vedere il risultato di TCPDUMP. Noterai in e out e l'indirizzo IP della VM utilizza l'indirizzo IP dell'endpoint PSC per connettersi a us-central1-aiplatform.googleapis.com

Chiudi tutte le sessioni SSH sull'istanza VM py-vm2

10. Esegui la pulizia

1. Vai a Cloud Shell, assicurati di essere nella directory terraform-build cd terraform-build ed esegui questo comando terraform destroy e digita yes tutte le risorse che hai creato nel tuo progetto con Terraform verranno rimosse.

11. Complimenti

Congratulazioni, hai eseguito correttamente la connessione alla chat di Vertex Gemini utilizzando sia l'indirizzo API pubblico sia l'endpoint Private Service Connect per le API di Google in privato. Questa funzionalità può estendere la connettività API privata nel tuo ambiente on-prem/altro cloud connesso tramite (interconnessione, Cross-Cloud Interconnect e VPC).

Prossimi passi/Scopri di più

Puoi scoprire di più sulla networking di Vertex AI

Codelab: Accedi ad Anthropic Claude su Vertex AI con l'SDK Python tramite l'endpoint Private Service Connect

Segui il prossimo lab

Continua la tua ricerca con Google Cloud e dai un'occhiata a questi altri lab Google Cloud Skills Boost:

• Concetti fondamentali sul networking in Google Cloud
• Generative AI Explorer - Vertex AI