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

1. Panoramica

È possibile accedere all'API Vertex AI tramite internet, ma nella tua azienda potresti voler accedere all'API Vertex AI in privato senza utilizzare internet. In questo lab accederai prima all'API di chat Vertex Gemini tramite l'SDK Python in esecuzione su un'istanza VM tramite la rete internet pubblica.

Poi, dovrai creare un endpoint Private Service Connect per le API di Google e modificare il flusso di traffico in modo da utilizzare l'endpoint privato per connetterti all'API di chat Gemini. Le configurazioni saranno una combinazione di Terraform, gcloud e console.

In questo lab creerai il seguente pattern.

Figura 1.

8b283cc5684283c2.png

2. Obiettivo

In questo lab imparerai a:

  • Configura l'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à a Google Cloud
  • Configura le voci DNS manuali

Configurazione dell'ambiente a tuo ritmo

  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.

fbef9caa1602edd0.png

a99b7ace416376c4.png

5e3ff691252acf41.png

  • 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 aggiornarlo.
  • L'ID progetto è univoco per tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo essere stato impostato). La console Cloud genera automaticamente una stringa univoca; di solito non ti interessa quale sia. Nella maggior parte dei codelab, dovrai fare riferimento al tuo ID progetto (in genere identificato come PROJECT_ID). Se l'ID generato non ti piace, puoi generarne un altro casuale. In alternativa, puoi provare il tuo e vedere 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.
  1. Successivamente, dovrai abilitare la fatturazione nella console Cloud per utilizzare le API/risorse Cloud. La partecipazione a questo codelab non ha costi, o quasi. Per arrestare le risorse ed evitare di incorrere in fatturazione al termine di questo tutorial, puoi eliminare le risorse che hai creato o il progetto. I nuovi utenti di Google Cloud sono idonei al programma Prova senza costi di 300$.

Avvia Cloud Shell

Sebbene Google Cloud possa 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:

55efc1aaa7a4d3ad.png

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

7ffe5cbb04455448.png

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 devi 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 in alto a destra nella console, assicurati di vedere l'ID progetto corretto in Cloud Shell e conferma eventuali richieste di autorizzazione di accesso. 4261e776f64ea978.png
  2. Crea una cartella denominata terraform-build e spostati al suo interno
mkdir terraform-build  && cd terraform-build
  1. Crea i file main.tf e variable.tf.
touch main.tf variable.tf
  1. Passa alla visualizzazione dell'editor di Cloud Shell. Seleziona editor, assicurati di consentire eventuali richieste necessarie per il caricamento dell'interfaccia.
  2. 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. 78f5eb9f2f82f1b0.png
  3. 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"
}
  1. 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"

  1. Copia e incolla quanto segue nel file main .tf.
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"]
}
  1. 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 scarica i provider necessari per la configurazione specificata.

terraform plan

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

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

4. Attività 2: Creare un 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, vai alla cartella terraform-build e crea i seguenti file (in totale tre file). Le modificheremo in un secondo momento.
touch nat-vm.tf psc.tf dns.tf
  1. 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
}
  1. Passa al terminale Cloud Shell, assicurati di essere nella cartella terraform-build ed esegui terraform plan per visualizzare l'aggiunta di 4 elementi, quindi esegui terraform apply e digita yes per creare il gateway NAT e due VM.

5. Attività 3: Configura le VM e testa

  1. Vai alle istanze VM. Seleziona la VM che inizia con py-vm1. Scegli SSH.
  2. Dopo aver eseguito l'accesso SSH a py-vm1,attiva il ruolo root digitando sudo -i
  3. Attiva l'ambiente venv:
cd py-gem-env
source env/bin/activate
  1. Ora autentichiamoci per eseguire alcuni test in un secondo momento. Esegui il seguente comando nella VM, premi y quando richiesto.
gcloud auth application-default login
  1. 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.
  2. Quando viene visualizzato il seguente messaggio, seleziona Copia, torna alla sessione della VM py-vm1 e in Inserisci codice di autorizzazione incolla il codice che hai copiato e premi Invio per autenticarti.

c29615cdf9324209.png

  1. Ora facciamo un rapido test per vedere se riusciamo a connetterci all'API Vertex Gemini, che utilizza us-central1-aiplatform.googleapis.com, quindi eseguiremo un dig a quell'indirizzo per vedere come viene indirizzato il traffico.
dig us-central1-aiplatform.googleapis.com
  1. 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
  1. Ora utilizziamo Python. Digita ipython per attivare l'interfaccia ipython.
ipython

4685b31f13df54e1.png

  1. 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))
  1. Premi Invio per eseguire il comando e visualizzare il risultato.
  2. Questa richiesta ha eseguito l'accesso a Vertex tramite l'API pubblica.
  3. Chiudi la sessione SSH e continuiamo.

Ora configura py-vm2 con le stesse configurazioni

  1. Vai alle istanze VM. Seleziona la VM che inizia con py-vm2. Scegli SSH.
  2. Dopo aver eseguito l'accesso SSH a py-vm2-****, abilita il ruolo root digitando **sudo -i**
  3. Attiva l'ambiente venv:
cd py-gem-env
source env/bin/activate
  1. Ora autentichiamoci per eseguire alcuni test in un secondo momento. Esegui questo comando nella VM
gcloud auth application-default login
  1. 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.
  2. 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.

c29615cdf9324209.png

  1. 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
  1. Torneremo a testare questa VM in un secondo momento. Chiudi la sessione SSH e continuiamo.

6. Attività 4: Creare l'endpoint PSC per googleapis con Terraform

Per abilitare la connettività privata all'endpoint dell'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 = ""
  }
  1. 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 2 elementi,
    poi esegui terraform apply e digita yes per creare l'endpoint delle API Google per IP e PSC.
  2. 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

Eseguiamo la connessione utilizzando l'endpoint privato per connetterci 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
  1. 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. Si tratta di un endpoint PSC e i tuoi ping non andranno a buon fine.
ping -c 2 us-central1-aiplatform.googleapis.com
  1. Torna alla console e apri un'altra istanza dell'istanza VM py-vm1. Seleziona SSH e accedi tramite SSH alla VM
  2. Accedi all'accesso root digitando sudo -i
  3. 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
  1. Ora torna alla prima istanza SSH dell'istanza VM py-vm1.
  2. Attiva l'ambiente utilizzando
cd py-gem-env
source env/bin/activate
  1. Ora testiamo Python. Digita ipython per attivare l'interfaccia ipython. Questa volta il traffico passerà attraverso l'endpoint PSC.
ipython
  1. Ora copia e incolla quanto segue. 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 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 = "Describe Niagara Falls"
print(get_chat_response(chat_session, prompt))
  1. Premi Invio per eseguire il codice e visualizzare il risultato.
  2. Torna alla seconda istanza dell'istanza VM py-vm1. Dovresti vedere il risultato di TCPDUMP. Vedrai In e Out con gli indirizzi IP della VM e anche l'indirizzo IP dell'endpoint PSC per connetterti 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
  1. 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 che rimandi 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. In Zone dovresti vedere una zona creata automaticamente per Private Service Connect per le API di Google, con la directory dei servizi di 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".
  1. Apri Cloud Shell nella visualizzazione dell'editor, se non è già aperto. Apri il file dns.tf nella cartella terraform-build. Aggiungi il codice seguente al file.

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."]  
}
  1. Passa al terminal Cloud Shell e assicurati di essere nella cartella terraform-build. Quindi, esegui terraform plan per visualizzare gli elementi che verranno aggiunti,
    poi esegui terraform apply e digita yes per creare la voce DNS privata.
  2. Dovresti vedere una configurazione con un record A e CNAME come questo, vedi b7f122f0d1fd2850.png
  3. Successivamente, verificheremo la connettività con queste modifiche su py-vm2

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

Eseguiamo la connessione utilizzando l'endpoint privato per connetterci a Gemini.

  1. Vai all'istanza VM py-vm2. Seleziona SSH e accedi tramite SSH alla VM
  2. Accedi all'accesso root digitando 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
  1. 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
  1. Controlla il percorso di connettività a us-central1-aiplatform.googleapis.com utilizzando il comando dig. Deve essere l'indirizzo IP dell'endpoint PSC.
dig us-central1-aiplatform.googleapis.com
  1. Torna alla console e apri un'altra istanza dell'istanza VM py-vm2. Seleziona SSH e accedi tramite SSH alla VM
  2. Accedi all'accesso root digitando sudo -i
  3. 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
  1. Ora torna alla prima istanza SSH dell'istanza VM py-vm2
  2. Attiva l'ambiente utilizzando
cd py-gem-env
source env/bin/activate
  1. Ora testiamo Python. Digita ipython per attivare l'interfaccia ipython.
ipython
  1. Ora copia e incolla quanto segue. Chiedi a Gemini "Quali sono tutti i colori del logo di 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))
  1. Premi Invio per eseguire il codice e visualizzare il risultato.
  2. 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 con l'istanza VM py-vm2

10. Esegui la pulizia

  1. Vai a Cloud Shell, assicurati di trovarti nella directory terraform-build cd terraform-build ed esegui il seguente 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à delle API private al tuo ambiente on-premise/di altro cloud connesso tramite (Interconnect, 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: