Diese Seite wurde von der Cloud Translation API übersetzt.

Über einen Private Service Connect-Endpunkt mit dem Python SDK auf den Gemini 3 Pro-Chat zugreifen

1. Übersicht

Auf die Vertex AI API kann über das Internet zugegriffen werden. In Ihrem Unternehmen möchten Sie jedoch möglicherweise privat auf die Vertex AI API zugreifen, ohne das Internet zu nutzen. In diesem Lab

Über das Python SDK über Vertex auf die Gemini 3 Pro API zugreifen
Dies wird auf einer VM-Instanz ausgeführt.
Die Verbindung erfolgt über Cloud NAT zum öffentlichen Internet.

Anschließend erstellen Sie einen Private Service Connect-Endpunkt für Google APIs und ändern den Trafficfluss so, dass der private Endpunkt verwendet wird, um eine Verbindung zur Gemini Chat API herzustellen. Die Konfigurationen sind eine Kombination aus Terraform, gcloud und Console.

In diesem Lab erstellen Sie das folgende Muster.

Abbildung 1:

2. Ziel

Aufgaben in diesem Lab:

VM-Instanz für die Verwendung des Python SDK einrichten
Über ein Python-Script eine Verbindung zu Gemini Chat herstellen
PSC-Endpunkt für die Verbindung zu Googleapis konfigurieren
Verbindungspfad zu Googleais prüfen
Manuelle DNS-Einträge konfigurieren

Einrichtung der Umgebung im eigenen Tempo

Melden Sie sich in der Google Cloud Console an und erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes Projekt. Wenn Sie noch kein Gmail- oder Google Workspace-Konto haben, müssen Sie eines erstellen.

Der Projektname ist der Anzeigename für die Teilnehmer dieses Projekts. Es handelt sich um einen String, der nicht von Google APIs verwendet wird. Sie können sie jederzeit aktualisieren.
Die Projekt-ID ist für alle Google Cloud-Projekte eindeutig und unveränderlich (kann nach dem Festlegen nicht mehr geändert werden). In der Cloud Console wird automatisch ein eindeutiger String generiert. Normalerweise ist es nicht wichtig, wie dieser String aussieht. In den meisten Codelabs müssen Sie auf Ihre Projekt-ID verweisen (in der Regel als PROJECT_ID angegeben). Wenn Ihnen die generierte ID nicht gefällt, können Sie eine andere zufällige ID generieren. Alternativ können Sie es mit einem eigenen Namen versuchen. Sie kann nach diesem Schritt nicht mehr geändert werden und bleibt für die Dauer des Projekts bestehen.
Zur Information: Es gibt einen dritten Wert, die Projektnummer, die von einigen APIs verwendet wird. Weitere Informationen zu diesen drei Werten

Als Nächstes müssen Sie die Abrechnung in der Cloud Console aktivieren, um Cloud-Ressourcen/-APIs zu verwenden. Die Durchführung dieses Codelabs kostet wenig oder gar nichts. Wenn Sie Ressourcen herunterfahren möchten, um Kosten zu vermeiden, die über diese Anleitung hinausgehen, können Sie die erstellten Ressourcen oder das Projekt löschen. Neue Google Cloud-Nutzer können am Programm Kostenlose Testversion mit einem Guthaben von 300$ teilnehmen.

Cloud Shell starten

Während Sie Google Cloud von Ihrem Laptop aus per Fernzugriff nutzen können, wird in diesem Codelab Google Cloud Shell verwendet, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.

Klicken Sie in der Google Cloud Console rechts oben in der Symbolleiste auf das Cloud Shell-Symbol:

Cloud Shell aktivieren

Die Bereitstellung und Verbindung mit der Umgebung sollte nur wenige Augenblicke dauern. Anschließend sehen Sie in etwa Folgendes:

Screenshot des Google Cloud Shell-Terminals, auf dem zu sehen ist, dass die Umgebung verbunden ist

Diese virtuelle Maschine verfügt über sämtliche Entwicklertools, die Sie benötigen. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft in Google Cloud, was die Netzwerkleistung und Authentifizierung erheblich verbessert. Alle Aufgaben in diesem Codelab können in einem Browser ausgeführt werden. Sie müssen nichts installieren.

3. Aufgabe 1: Umgebung mit Terraform einrichten

Wir erstellen eine benutzerdefinierte VPC mit Firewallregeln und einem Subnetz. Öffnen Sie die Cloud Console und wählen Sie das Projekt aus, das Sie verwenden möchten.

Öffnen Sie Cloud Shell oben rechts in der Konsole. Prüfen Sie, ob die richtige Projekt-ID in Cloud Shell angezeigt wird, und bestätigen Sie alle Aufforderungen zum Zulassen des Zugriffs.
Erstellen Sie einen Ordner mit dem Namen „terraform-build“ und wechseln Sie in den Ordner.

mkdir terraform-build  && cd terraform-build

Erstellen Sie die Dateien main.tf und variable.tf.

touch main.tf variable.tf

Wechseln Sie zur Ansicht Cloud Shell-Editor. Wählen Sie Editor aus und bestätigen Sie alle erforderlichen Aufforderungen, damit die Benutzeroberfläche geladen werden kann.
Rufen Sie nach dem Laden Datei > Ordner öffnen auf, wechseln Sie zu /home/your-user-name/terraform-build und wählen Sie Ok aus, um den Ordner im Editor zu öffnen.
Wählen Sie die Datei variable.tf aus und fügen Sie Folgendes hinzu. Ersetzen Sie den Text your-project-id-here durch Ihre tatsächliche Projekt-ID in Anführungszeichen.

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

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

Öffnen Sie als Nächstes die Datei main.tf. Wir fügen nun Terraform-Code hinzu, um verschiedene Aktionen auszuführen, wie unten beschrieben.

*APIs aktivieren*	`resource` `"google_project_service"` `"default"`
*VPC mit dem Namen „python-net“ erstellen*	`resource` `"google_compute_network"` `"default"`
*Subnetz hinzufügen*	`resource` `"google_compute_subnetwork"` `"default"`
*Zwei Firewallregeln hinzufügen*	`resource` `"google_compute_firewall"` `"allow_icmp"resource` `"google_compute_firewall"` `"allow_ssh"`

Kopieren Sie den folgenden Code in die Datei main .tf.

resource "google_project_service" "default" {
  project = var.project_id 
  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"
  project       = var.project_id
  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"]
}

Wechseln Sie zurück zum Cloud Shell-Terminal, achten Sie darauf, dass Sie sich im Verzeichnis terraform-build cd terraform-build befinden, und führen Sie die folgenden Befehle aus.

terraform init

Initialisiert das Arbeitsverzeichnis. In diesem Schritt werden die für die angegebene Konfiguration erforderlichen Anbieter heruntergeladen.

terraform plan

Erstellt einen Ausführungsplan, der zeigt, welche Aktionen Terraform zum Bereitstellen Ihrer Infrastruktur ausführt.

Führen Sie nun den Befehl terraform apply aus und geben Sie yes ein, um die Ressourcen zu erstellen.

4. Aufgabe 2: NAT-Gateway und VMs mit Terraform erstellen

Wir müssen ausgehenden externen Zugriff auf das Internet gewähren. Erstellen wir also ein Cloud NAT-Gateway und hängen wir es an.

Öffnen Sie Cloud Shell, rufen Sie den Ordner „terraform-build“ auf und erstellen Sie die folgenden Dateien (insgesamt drei Dateien). Wir werden diese später bearbeiten.

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

Wechseln Sie zur Ansicht Cloud Shell-Editor, wählen Sie die Datei nat-vm.tf aus und fügen Sie den folgenden Terraform-Code hinzu. Dadurch werden ein NAT-Gateway und zwei VMs erstellt.

Terraform nat-vm.tf

resource "google_compute_router" "default" {
  name    = "py-outbound-nat"
  region  = "us-east1"
  network = google_compute_network.default.id
  project = var.project_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"
  project                            = var.project_id
  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"
  project      = var.project_id

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

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

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

  metadata_startup_script = <<-EOF
    #! /bin/bash
    sudo apt-get update
    sudo apt-get install python3 python3-dev python3-venv git -y
    sudo apt-get install tcpdump dnsutils -y    
    
      mkdir -p ~/py-gem-env
      cd ~/py-gem-env
      python3 -m venv env
      source env/bin/activate
      pip install --upgrade pip
      pip install ipython google-genai
    '
  EOF
}

Wechseln Sie zum Cloud Shell-Terminal, achten Sie darauf, dass Sie sich im Ordner terraform-build befinden, und führen Sie terraform plan aus. Dadurch wird angezeigt, dass 4 Elemente hinzugefügt werden. Führen Sie dann terraform apply aus und geben Sie yes ein, um das NAT-Gateway und die VM zu erstellen.

5. Aufgabe 3: VMs konfigurieren und testen

Rufen Sie „VM-Instanzen“ auf. Wählen Sie die VM aus, die mit py-vm1 beginnt. Wählen Sie SSH aus.
Sobald Sie eine SSH-Verbindung zu py-vm1 hergestellt haben, aktivieren Sie den Root-Zugriff, indem Sie sudo -i eingeben.
Aktivieren Sie Ihre venv-Umgebung:

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

Jetzt authentifizieren wir das, um später einige Tests durchzuführen. Führen Sie den folgenden Befehl in der VM aus und drücken Sie bei Aufforderung y.

gcloud auth application-default login

Kopieren Sie als Nächstes die URL, die mit https:// beginnt, öffnen Sie einen neuen Tab in Ihrem Lab-Browserfenster und fügen Sie die URL ein. Akzeptieren Sie die Aufforderungen.
Wenn Sie Folgendes sehen, wählen Sie „Kopieren“ aus, wechseln Sie zurück zur Sitzung der VM py-vm1 und fügen Sie den kopierten Code bei Autorisierungscode eingeben: ein. Drücken Sie dann die Eingabetaste, um sich zu authentifizieren.

Führen wir nun einen kurzen Test durch, um zu sehen, ob wir eine Verbindung zur Vertex AI API herstellen können. Dazu wird *-aiplatform.googleapis.com verwendet. Wir führen also einen dig an diese Adresse aus, um zu sehen, wie der Traffic weitergeleitet wird.

dig *-aiplatform.googleapis.com

Die Ausgabe sollte in etwa so aussehen (die Adresse ist jedoch anders). Hinweis: Der Pfad verläuft über öffentliche IP-Adressen, da die API eine öffentliche API ist. NICHT KOPIEREN

; <<>> DiG 9.18.41-1~deb12u1-Debian <<>> *-aiplatform.googleapis.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 60947
;; flags: qr rd ra; QUERY: 1, ANSWER: 16, AUTHORITY: 0, ADDITIONAL: 1

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

;; ANSWER SECTION:
*-aiplatform.googleapis.com. 300 IN     A       173.194.216.95
*-aiplatform.googleapis.com. 300 IN     A       108.177.11.95
*-aiplatform.googleapis.com. 300 IN     A       192.178.219.95
*-aiplatform.googleapis.com. 300 IN     A       74.125.134.95
*-aiplatform.googleapis.com. 300 IN     A       74.125.139.95
*-aiplatform.googleapis.com. 300 IN     A       108.177.12.95
*-aiplatform.googleapis.com. 300 IN     A       173.194.210.95
*-aiplatform.googleapis.com. 300 IN     A       74.125.26.95
*-aiplatform.googleapis.com. 300 IN     A       173.194.212.95
*-aiplatform.googleapis.com. 300 IN     A       172.217.204.95

Jetzt verwenden wir Python. Geben Sie ipython ein, um die ipython-Schnittstelle zu aktivieren.

ipython

Kopieren Sie nun den folgenden Befehl und fügen Sie ihn ein. Gemini wird dann gefragt: Welche Farben hat das Google-Logo? und Welche Farbe hat der Himmel?

from google import genai
from google.genai import types
import os
import sys

LOCATION = "global"
MODEL_ID = "gemini-3-pro-preview" 

try:
    client = genai.Client(vertexai=True, location=LOCATION)
    print(f"Successfully initialized Google Gen AI Client (Vertex AI mode) in {LOCATION}")
except Exception as e:
    print(f"Error initializing client: {e}")
    print("Ensure you have installed the library: `pip install google-genai`")
    print("And authenticated: `gcloud auth application-default login`")
    sys.exit(1)

class SimpleChatSession:
    def __init__(self, model_id):
        self.model_id = model_id
        self.history = [] 

    def send_message(self, prompt, stream=True):
        user_content = types.Content(
            role="user",
            parts=[types.Part(text=prompt)]
        )
        self.history.append(user_content)

        try:
            response_stream = client.models.generate_content_stream(
                model=self.model_id,
                contents=self.history,
                config=types.GenerateContentConfig(
                    temperature=0.7 
                )
            )

            accumulated_text = ""
            
            for chunk in response_stream:
                if chunk.text:
                    yield chunk.text
                    accumulated_text += chunk.text
            
            model_content = types.Content(
                role="model",
                parts=[types.Part(text=accumulated_text)]
            )
            self.history.append(model_content)

        except Exception as e:
            print(f"\n[Error during generation: {e}]")

def get_chat_response(session: SimpleChatSession, prompt: str):
    print(f"\n--- User: {prompt} ---")
    print("--- Model: ", end="")
    
    stream_generator = session.send_message(prompt)
    
    full_text = ""
    for chunk_text in stream_generator:
        full_text += chunk_text
        print(chunk_text, end="", flush=True)

    print() 
    return full_text

if __name__ == "__main__":
    chat_session = SimpleChatSession(MODEL_ID)

    get_chat_response(chat_session, "Hello.")
    get_chat_response(chat_session, "What are all the colors of the Google logo?")
    get_chat_response(chat_session, "What color is the sky?")

Drücken Sie zweimal die Eingabetaste, um den Befehl auszuführen und das Ergebnis zu sehen.
Bei dieser Anfrage wurde über die öffentliche API auf Vertex zugegriffen.
Schließen Sie die SSH-Sitzung und fahren Sie fort.

6. Aufgabe 4: PSC-Endpunkt für googleapis mit Terraform erstellen

Um eine private Verbindung zu unserem Vertex API-Endpunkt zu ermöglichen, erstellen wir einen Private Service Connect-Endpunkt für Google APIs. So können wir eine private IP-Adresse verwenden, die wir zuweisen, um Traffic an die benötigten Google APIs weiterzuleiten, in diesem Fall Vertex.

Öffnen Sie Cloud Shell in der Editoransicht, falls sie noch nicht geöffnet ist. Wir erstellen Folgendes:

Erstellen Sie eine IP-Adresse für den PSC-Endpunkt 192.168.255.250 (resource "google_compute_global_address" "default")
PSC-Endpunkt für Google APIs erstellen (resource "google_compute_global_forwarding_rule" "default")

Öffnen Sie die Datei psc.tf im Ordner terraform-build. Fügen Sie der Datei den folgenden Code hinzu.

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

Wechseln Sie zum Cloud Shell-Terminal und prüfen Sie, ob Sie sich im Ordner terraform-build befinden. Führen Sie dann terraform init aus. Führen Sie dann terraform plan aus. Dadurch wird angezeigt, dass zwei Elemente hinzugefügt werden.
Führen Sie dann terraform apply aus und geben Sie yes ein, um den IP- und PSC-Google APIs-Endpunkt zu erstellen.
Vorhandensein des Endpunkts prüfen

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

gcloud compute forwarding-rules describe pscvertexgemini --global

7. Aufgabe 5: Manuellen DNS-Eintrag für googleapis mit Terraform erstellen

Sie können einen manuellen DNS-Eintrag erstellen, der mit privatem DNS auf den PSC-Endpunkt verweist. Das wirkt sich auf alle Netzwerke aus, die Sie ihm zuweisen.

Rufen Sie „Netzwerkdienste“ auf und wählen Sie „Cloud DNS“ aus.
In Zonen sollte eine automatisch erstellte Zone für Private Service Connect für Google APIs mit dem Zonentypservicedirectory angezeigt werden. Damit kann eine Verbindung zum PSC-Endpunkt im Format **SERVICE-ENDPOINT.p.googleapis.com hergestellt werden. Beispiel: aiplatform-pscvertexgemini.p.googleapis.com
In diesem Fall möchten wir manuell einen privaten DNS-Eintrag erstellen. Die Konfiguration sieht so aus:

Erstellen Sie eine private DNS-Zone mit dem Namen „googleapis-private“ für „googleapis.com“ und beschränken Sie sie auf das Netzwerk „python-net“.
Fügen Sie einen A-Eintrag hinzu, um „googleapis.com“ der IP-Adresse „192.168.255.250“ zuzuordnen.
Fügen Sie einen CNAME-Eintrag hinzu, um alle Subdomains von „googleapis.com“ (z.B. www.googleapis.com) zu „googleapis.com“ weiterzuleiten.

Öffnen Sie Cloud Shell in der Editoransicht, falls sie noch nicht geöffnet ist. Öffnen Sie die Datei dns.tf im Ordner „terraform-build“. Fügen Sie den folgenden Code in die Datei ein.

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."]  
}

Wechseln Sie zum Cloud Shell-Terminal und prüfen Sie, ob Sie sich im Ordner terraform-build befinden. Führen Sie dann terraform plan aus. Dadurch wird angezeigt, welche Elemente hinzugefügt werden.
Führen Sie dann terraform apply aus und geben Sie yes ein, um den privaten DNS-Eintrag zu erstellen.
Sie sollten eine Einrichtung mit einem A-Eintrag und einem CNAME-Eintrag wie in sehen.
Als Nächstes prüfen wir die Konnektivität mit diesen Änderungen auf py-vm1.

8. Aufgabe 6: Endpunktverbindung über IP-Adresse prüfen

Wir stellen eine Verbindung über den privaten Endpunkt her, um eine Verbindung zu Gemini herzustellen.

Rufen Sie die VM-Instanz py-vm1 auf. Wählen Sie „SSH“ aus und stellen Sie eine SSH-Verbindung zur VM her
Root-Zugriff durch Eingabe von sudo -i erhalten
Prüfen Sie den Verbindungspfad zu aiplatform.googleapis.com mit dem Befehl ping. Dadurch wird die IP-Adresse im privaten DNS, A-Eintrag für googleapis, angepingt. Diese IP-Adresse ist ein PSC-Endpunkt und Ihre Pings schlagen fehl.

ping -c 2 aiplatform.googleapis.com

Prüfen Sie den Verbindungspfad mit einem ping über den automatisch erstellten DNS-Eintrag für PSC-Google APIs mit aiplatform-pscvertexgemini.p.googleapis.com. Dies verweist auf die IP-Adresse des PSC-Endpunkts und Ihre Pings sind nicht erfolgreich.

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

Prüfen Sie den Verbindungspfad zu aiplatform.googleapis.com mit dem Befehl dig. Dies sollte die IP-Adresse des PSC-Endpunkts sein.

dig aiplatform.googleapis.com

Kehren Sie zur Console zurück und öffnen Sie eine weitere Instanz von VM-Instanz py-vm1. Wählen Sie SSH aus und stellen Sie eine SSH-Verbindung zur VM her.
Root-Zugriff durch Eingabe von sudo -i erhalten
Führen Sie den folgenden Befehl aus, um die Verbindung in einem TCP-Dump zu sehen.

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

Wechseln Sie nun zurück zur ersten SSH-Instanz der VM-Instanz py-vm1.
Aktivieren Sie die Umgebung mit

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

Jetzt testen wir Python. Geben Sie ipython ein, um die ipython-Schnittstelle zu aktivieren.

ipython

Kopieren Sie nun den folgenden Befehl und fügen Sie ihn ein. Gemini wird gefragt: Fasse in einem kurzen Satz zusammen, was ein Tokenizer im Kontext von KI ist. und Sind Wale toll oder nicht?.

from google import genai
from google.genai import types
import os
import sys

LOCATION = "global"
MODEL_ID = "gemini-3-pro-preview" 

try:
    client = genai.Client(vertexai=True, location=LOCATION)
    print(f"Successfully initialized Google Gen AI Client (Vertex AI mode) in {LOCATION}")
except Exception as e:
    print(f"Error initializing client: {e}")
    print("Ensure you have installed the library: `pip install google-genai`")
    print("And authenticated: `gcloud auth application-default login`")
    sys.exit(1)

class SimpleChatSession:
    def __init__(self, model_id):
        self.model_id = model_id
        self.history = [] 

    def send_message(self, prompt, stream=True):
        user_content = types.Content(
            role="user",
            parts=[types.Part(text=prompt)]
        )
        self.history.append(user_content)

        try:
            response_stream = client.models.generate_content_stream(
                model=self.model_id,
                contents=self.history,
                config=types.GenerateContentConfig(
                    temperature=0.7 
                )
            )

            accumulated_text = ""
            
            for chunk in response_stream:
                if chunk.text:
                    yield chunk.text
                    accumulated_text += chunk.text
            
            model_content = types.Content(
                role="model",
                parts=[types.Part(text=accumulated_text)]
            )
            self.history.append(model_content)

        except Exception as e:
            print(f"\n[Error during generation: {e}]")

def get_chat_response(session: SimpleChatSession, prompt: str):
    print(f"\n--- User: {prompt} ---")
    print("--- Model: ", end="")
    
    stream_generator = session.send_message(prompt)
    
    full_text = ""
    for chunk_text in stream_generator:
        full_text += chunk_text
        print(chunk_text, end="", flush=True)

    print() 
    return full_text

if __name__ == "__main__":
    chat_session = SimpleChatSession(MODEL_ID)

    get_chat_response(chat_session, "Hello.")
    get_chat_response(chat_session, "In one short sentence summarize what is a tokenizer in the context of AI?")
    get_chat_response(chat_session, "Are whales awesome or not?")

Drücken Sie zweimal die Eingabetaste, um die Suche auszuführen und das Ergebnis zu sehen.
Wechseln Sie zurück zur zweiten Instanz von „VM Instance“ py-vm1. Sie sollten das Ergebnis von TCPDUMP sehen. Sie sehen, dass die IP-Adresse der VM die IP-Adresse des PSC-Endpunkts verwendet, um eine Verbindung zu aiplatform.googleapis.com herzustellen.

Schließen Sie alle SSH-Sitzungen zur VM-Instanz py-vm1.

9. Bereinigen

Rufen Sie Cloud Shell auf und prüfen Sie, ob Sie sich im Verzeichnis terraform-build befinden cd terraform-build
Führen Sie terraform plan destroy aus, um alle Änderungen zu sehen, die vorgenommen werden.

terraform plan -destroy

Führen Sie dann den Befehl terraform destroy aus und geben Sie yes ein. Alle Ressourcen, die Sie mit Terraform in Ihrem Projekt erstellt haben, werden entfernt.

terraform destroy

10. Glückwunsch

Sie haben erfolgreich eine Verbindung zu Vertex hergestellt und Gemini 3 Pro über die öffentliche API-Adresse und privat über den Private Service Connect-Endpunkt für Google APIs verwendet. Mit dieser Funktion können Sie private API-Verbindungen auf Ihre lokale Umgebung oder andere Cloud-Umgebungen ausweiten, die über Interconnect, Cross-Cloud Interconnect und VPC verbunden sind.

Weitere Informationen

Weitere Informationen zum Vertex AI-Netzwerk

Codelab: Über einen Private Service Connect-Endpunkt mit dem Python SDK auf Anthropic Claude in Vertex AI zugreifen

Nächstes Lab absolvieren

Fahren Sie mit Google Cloud fort und sehen Sie sich die folgenden Labs von Google Cloud Skills Boost an: