Auf den Gemini-Chat mit dem Python SDK über den Private Service Connect-Endpunkt zugreifen

1. Übersicht

Sie können über das Internet auf die Vertex AI API zugreifen. In Ihrem Unternehmen möchten Sie jedoch möglicherweise privat auf die Vertex AI API zugreifen, ohne das Internet zu nutzen. In diesem Lab greifen Sie zuerst über das öffentliche Internet über das Python SDK auf einer VM-Instanz auf die Vertex Gemini Chat API zu.

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

In diesem Lab erstellen Sie das folgende Muster.

Abbildung 1.

2. Ziel

In diesem Lab lernen Sie, wie Sie die folgenden Aufgaben ausführen:

• 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

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

• Der Projektname ist der Anzeigename für die Teilnehmer dieses Projekts. Es ist ein Zeichenstring, der von Google APIs nicht verwendet wird. Sie können ihn jederzeit aktualisieren.
• Die Projekt-ID ist für alle Google Cloud-Projekte eindeutig und kann nach der Festlegung nicht mehr geändert werden. In der Cloud Console wird automatisch ein eindeutiger String generiert. In der Regel spielt es keine Rolle, wie er lautet. In den meisten Codelabs müssen Sie auf Ihre Projekt-ID verweisen (normalerweise als PROJECT_ID gekennzeichnet). Wenn Ihnen die generierte ID nicht gefällt, können Sie eine andere zufällige generieren. Alternativ können Sie Ihr eigenes Konto ausprobieren und prüfen, ob es verfügbar ist. 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 finden Sie in der Dokumentation.

Achtung:Eine Projekt-ID ist global eindeutig und kann nach der Auswahl nicht mehr von anderen verwendet werden. Sie sind der einzige Nutzer dieser ID. Auch wenn ein Projekt gelöscht wird, kann die ID nicht wiederverwendet werden.

Hinweis:Wenn Sie ein Gmail-Konto verwenden, können Sie den Standardspeicherort auf Keine Organisation belassen. Wenn Sie ein Google Workspace-Konto verwenden, wählen Sie einen Standort aus, der für Ihre Organisation sinnvoll ist.

2. Als Nächstes müssen Sie die Abrechnung in der Cloud Console aktivieren, um Cloud-Ressourcen/-APIs verwenden zu können. Die Durchführung dieses Codelabs ist kostenlos oder kostet nur sehr wenig. Wenn Sie die Ressourcen deaktivieren möchten, um Kosten nach Abschluss dieser Anleitung zu vermeiden, können Sie die von Ihnen erstellten Ressourcen oder das Projekt löschen. Neuen Google Cloud-Nutzern steht das kostenlose Testprogramm mit einem Guthaben von 300$ zur Verfügung.

Cloud Shell starten

Sie können Google Cloud zwar per Fernzugriff von Ihrem Laptop aus nutzen, in diesem Codelab verwenden Sie jedoch Google Cloud Shell, 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:

Die Bereitstellung und Verbindung mit der Umgebung sollte nur wenige Minuten dauern. Wenn der Vorgang abgeschlossen ist, sollte in etwa Folgendes angezeigt werden:

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 auf Google Cloud. Dadurch werden 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 Subnetz. Öffnen Sie die Cloud Console und wählen Sie das Projekt aus, das Sie verwenden möchten.

1. Öffnen Sie Cloud Shell oben rechts in der Konsole. Achten Sie darauf, dass in Cloud Shell die richtige Projekt-ID angezeigt wird. Bestätigen Sie alle Aufforderungen, um den Zugriff zuzulassen.
2. Ordner „terraform-build“ erstellen und in den Ordner verschieben

mkdir terraform-build  && cd terraform-build

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

touch main.tf variable.tf 

4. Wechseln Sie zur Ansicht Cloud Shell-Editor. Wählen Sie editor aus und erlauben Sie alle erforderlichen Aufforderungen, damit die Benutzeroberfläche geladen werden kann.
5. Klicken Sie nach dem Laden auf Datei > Ordner öffnen und gehen Sie zu /home/your-user-name/terraform-build. Wählen Sie dann Ok aus, um den Ordner im Editor zu öffnen.
6. 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"
}

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

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"

8. Kopieren Sie den folgenden Code in die Datei 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"]
}

9. Wechseln Sie zurück zum Cloud Shell-Terminal, prüfen Sie, ob 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 jeweilige Konfiguration erforderlichen Anbieter heruntergeladen.

terraform plan

Er generiert einen Ausführungsplan, der zeigt, welche Aktionen Terraform ausführen wird, um Ihre Infrastruktur bereitzustellen.

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

Einrichtung überprüfen: Prüfen Sie Folgendes:

1 VPC mit dem Namen python-net

1 Subnetz

2 Firewallregeln

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

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

1. Öffnen Sie Cloud Shell, rufen Sie den Ordner „terraform-build“ auf und erstellen Sie die folgenden drei Dateien. Diese können wir später bearbeiten.

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

2. Wechseln Sie zum 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

 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. Wechseln Sie zum Cloud Shell-Terminal, prüfen Sie, ob Sie sich im Ordner terraform-build befinden, und führen Sie terraform plan aus. Daraufhin wird angezeigt, dass vier Elemente hinzugefügt werden. Führen Sie dann terraform apply und yes aus, um das NAT-Gateway und zwei VMs zu erstellen.

Einrichtung überprüfen: Prüfen Sie Folgendes:

1 NAT-Gateway

1 Cloud Router

VM mit dem Namen py-vm1

VM mit dem Namen py-vm2

5. Aufgabe 3: VMs konfigurieren und testen

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

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

4. Authentifizieren wir das jetzt, damit wir später einige Tests durchführen können. Führen Sie den folgenden Befehl in der VM aus und drücken Sie auf y, wenn Sie dazu aufgefordert werden.

gcloud auth application-default login

5. 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.
6. Wenn die folgende Auswahl angezeigt wird, wechseln Sie zurück zur VM-Sitzung py-vm1 und fügen Sie unter Autorisierungscode eingeben den kopierten Code ein. Drücken Sie dann die Eingabetaste, um sich zu authentifizieren.

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

dig us-central1-aiplatform.googleapis.com

8. Die Ausgabe sollte in etwa so aussehen (die Adresse unterscheidet sich). Hinweis: Der Pfad verläuft über öffentliche IP-Adressen, da es sich um eine öffentliche API handelt. NICHT KOPIEREN

; <<>> 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. Verwenden wir jetzt Python. Geben Sie ipython ein, um die ipython-Oberfläche zu aktivieren.

ipython

10. Kopieren Sie nun den folgenden Befehl und fügen Sie ihn ein. Dadurch wird Gemini gefragt: Welche Farben hat das Google-Logo? und Welche Farbe hat der Himmel? Ersetzen Sie enter-your-project-id-here in den Anführungszeichen durch Ihre Projekt-ID.

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. Drücken Sie die Eingabetaste, um das Programm auszuführen und das Ergebnis zu sehen.
12. Bei dieser Anfrage wurde über die öffentliche API auf Vertex zugegriffen.
13. Schließen Sie die SSH. Fahren Sie fort.

Hinweis:Sie können die Prompt-Frage ändern.

Jetzt py-vm2 mit denselben Konfigurationen konfigurieren

14. Rufen Sie „VM-Instanzen“ auf. Wählen Sie die VM aus, die mit py-vm2 beginnt. Wählen Sie „SSH“ aus.
15. Nachdem Sie eine SSH-Verbindung zu py-vm2 hergestellt haben, aktivieren Sie Root, indem Sie **sudo -i** eingeben.
16. Aktivieren Sie Ihre venv-Umgebung:

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

17. Authentifizieren wir das jetzt, damit wir später einige Tests durchführen können. Führen Sie in der VM den folgenden Befehl aus:

gcloud auth application-default login

18. 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.
19. Wenn die folgende Auswahl angezeigt wird, wechseln Sie zurück zur VM-Sitzung py-vm2 und fügen Sie unter Autorisierungscode eingeben den kopierten Code ein. Drücken Sie dann die Eingabetaste, um sich zu authentifizieren.

20. Führen wir jetzt einen kurzen Test durch, um zu sehen, ob wir eine Verbindung zur Vertex Gemini API herstellen können. Mit diesem Befehl werden vier Pings an us-central1-aiplatform.googleapis.com gesendet, damit wir eine Antwort von der öffentlichen Adresse der API erhalten.

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

21. Wir testen diese VM später noch einmal. Schließen Sie die SSH-Sitzung und fahren Sie fort.

6. Aufgabe 4: PSC-Endpunkt zu 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 von uns zugewiesene private IP-Adresse verwenden, um Traffic an die benötigten Google APIs weiterzuleiten, in diesem Fall Vertex.

1. Öffnen Sie Cloud Shell in der Editoransicht, falls noch nicht geschehen. 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 = ""
  }

2. Wechseln Sie zum Cloud Shell-Terminal und prüfen Sie, ob Sie sich im Ordner terraform-build befinden. Führen Sie dann terraform init und terraform plan aus. Sie sehen, dass zwei Elemente hinzugefügt werden.
   Führen Sie dann terraform apply und yes aus, um den IP- und PSC-Google APIs-Endpunkt zu erstellen.
3. Prüfen, ob Endpunkt vorhanden ist

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

gcloud compute forwarding-rules describe pscvertexgemini --global

7. Aufgabe 5: Endpunktverbindung über IP-Adresse prüfen

Stellen wir über den privaten Endpunkt eine Verbindung zu Gemini her.

1. Rufen Sie die VM-Instanz py-vm1 auf. Wählen Sie „SSH“ aus und stellen Sie eine SSH-Verbindung zur VM her.
2. Root-Zugriff durch Eingabe von sudo -i
3. Wir verwenden diese einzelne Instanz nur zum Testen des PSC-Endpunkts. Daher ändern wir die Hostdatei mit dem folgenden Eintrag:

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

cat /etc/hosts

Hinweis:Dadurch wird ein statischer Eintrag hinzugefügt, der der Adresse „us-central1-aiplatform.googleapis.com“ die PSC-Endpunkt-IP zuordnet.

4. Prüfen Sie mit dem Befehl ping den Verbindungspfad zu us-central1-aiplatform.googleapis.com. Dadurch wird ein Ping an die IP-Adresse gesendet, die Sie in den Hostdateien eingegeben haben. Dies ist ein PSC-Endpunkt und Ihre Pings schlagen fehl.

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

5. Kehren Sie zur Console zurück und öffnen Sie eine weitere Instanz der VM-Instanz py-vm1. Wählen Sie SSH aus und stellen Sie eine SSH-Verbindung zur VM her.
6. Root-Zugriff durch Eingabe von sudo -i
7. 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 us-central1-aiplatform.googleapis.com

8. Kehren Sie jetzt zur ersten SSH-Instanz der VM-Instanz py-vm1 zurück.
9. Aktivieren Sie die Umgebung mit

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

10. Testen wir jetzt Python. Geben Sie ipython ein, um die ipython-Oberfläche zu aktivieren. Diesmal fließt der Traffic über den PSC-Endpunkt.

ipython

11. Kopieren Sie nun den folgenden Befehl und fügen Sie ihn ein. Damit wird Gemini gefragt: Welche Farben hat das Google-Logo? und Beschreiben Sie die Niagarafälle. Ersetzen Sie enter-your-project-id-here in den Anführungszeichen durch Ihre Projekt-ID.

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. Drücken Sie die Eingabetaste, um das Script auszuführen und das Ergebnis zu sehen.
13. Kehren Sie zur zweiten Instanz der VM-Instanz py-vm1 zurück. Sie sollten das Ergebnis von TCPDUMP sehen. Sie sehen „In“ und „Out“ mit den IP-Adressen der VM und der IP-Adresse des PSC-Endpunkts, um eine Verbindung zu us-central1-aiplatform.googleapis.com herzustellen.

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. Schließen Sie alle SSH-Sitzungen zur VM-Instanz py-vm1.

8. Aufgabe 6: Manuellen DNS-Eintrag für googleapis mit Terraform erstellen (optional)

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.

1. Gehen Sie zu „Netzwerkdienste“ und wählen Sie „Cloud DNS“ aus.
2. Unter „Zonen“ sollte eine automatisch erstellte Zone für Private Service Connect für Google APIs mit dem Zonentyp „Service Directory“ angezeigt werden. Damit kann eine Verbindung zum PSC-Endpunkt im Format **SERVICE-ENDPOINT.p.googleapis.com hergestellt werden. Beispiel: aiplatform-pscvertexgemini.p.googleapis.com
3. In diesem Fall möchten wir einen privaten DNS-Eintrag manuell erstellen. Die Konfiguration sieht dann 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) auf „googleapis.com“ weiterzuleiten.

4. Öffnen Sie Cloud Shell in der Editoransicht, falls noch nicht geschehen. Ö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."]  
}

5. 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. Daraufhin sehen Sie, welche Elemente hinzugefügt werden.
   Führen Sie dann terraform apply aus und geben Sie yes ein, um den privaten DNS-Eintrag zu erstellen.
6. Sie sollten eine Einrichtung mit einem A-Eintrag und einem CNAME wie diesem sehen ().
7. Als Nächstes prüfen wir die Verbindung mit diesen Änderungen auf py-vm2.

9. Aufgabe 7: Endpunktverbindung über IP-Adresse prüfen (optional)

Stellen wir über den privaten Endpunkt eine Verbindung zu Gemini her.

Hinweis:Auf der VM sind keine manuellen Konfigurationen erforderlich.

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

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

4. Prüfen Sie den Verbindungspfad mit einer ping mit dem 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

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

dig us-central1-aiplatform.googleapis.com

6. Kehren Sie zur Console zurück und öffnen Sie eine weitere Instanz der VM-Instanz py-vm2. Wählen Sie SSH aus und stellen Sie eine SSH-Verbindung zur VM her.
7. Root-Zugriff durch Eingabe von sudo -i
8. 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 us-central1-aiplatform.googleapis.com

9. Wechseln Sie jetzt zurück zur ersten SSH-Instanz der VM-Instanz py-vm2.
10. Aktivieren Sie die Umgebung mit

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

11. Testen wir jetzt Python. Geben Sie ipython ein, um die ipython-Oberfläche zu aktivieren.

ipython

12. Kopieren Sie nun den folgenden Befehl und fügen Sie ihn ein. Hier wird Gemini gefragt: Welche Farben hat das Google-Logo? und Welche zwei Funktionen hat Gemini Pro? Ersetzen Sie enter-your-project-id-here in den Anführungszeichen durch Ihre Projekt-ID.

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. Drücken Sie die Eingabetaste, um das Script auszuführen und das Ergebnis zu sehen.
14. Kehren Sie zur zweiten Instanz der VM-Instanz py-vm2 zurück. Sie sollten das Ergebnis des TCPDUMP sehen. Sie sehen „in“ und „out“ und die IP-Adresse der VM verwendet die IP-Adresse des PSC-Endpunkts, um eine Verbindung zu us-central1-aiplatform.googleapis.com herzustellen.

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

10. Bereinigen

1. Rufen Sie Cloud Shell auf und prüfen Sie, ob Sie sich im Verzeichnis terraform-build cd terraform-build befinden. Führen Sie dann den folgenden Befehl aus terraform destroy und geben Sie yes ein. Alle Ressourcen, die Sie in Ihrem Projekt mit Terraform erstellt haben, werden entfernt.

11. Glückwunsch

Herzlichen Glückwunsch! Sie haben eine Verbindung zum Vertex Gemini-Chat sowohl über die öffentliche API-Adresse als auch privat über den Private Service Connect-Endpunkt für Google APIs hergestellt. Mit dieser Funktion können Sie die Private API-Konnektivität auf Ihre lokale Umgebung oder eine andere Cloud-Umgebung ausweiten, die über Interconnect, Cross-Cloud Interconnect und VPC verbunden sind.

Weitere Informationen

Weitere Informationen zum Networking in Vertex AI

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

Nächstes Lab absolvieren

Setzen Sie die Aufgabenreihe mit Google Cloud fort und sehen Sie sich diese anderen Google Cloud Skills Boost-Labs an:

• Netzwerkgrundlagen in Google Cloud
• Generative AI Explorer – Vertex AI