Accéder à la discussion Gemini avec le SDK Python via un point de terminaison Private Service Connect

1. Présentation

Vous pouvez accéder à l'API Vertex AI via Internet. Toutefois, dans votre entreprise, vous pouvez souhaiter accéder à l'API Vertex AI en privé, sans passer par Internet. Dans cet atelier, vous allez d'abord accéder à l'API de chat Vertex Gemini via le SDK Python exécuté sur une instance de VM via l'Internet public.

Vous allez ensuite créer un point de terminaison Private Service Connect pour les API Google et modifier le flux de trafic afin d'utiliser le point de terminaison privé pour vous connecter à l'API Gemini Chat. Les configurations combineront Terraform, gcloud et la console.

Dans cet atelier, vous allez créer le modèle suivant.

Figure1.

2. Objectif

Dans cet atelier, vous allez apprendre à effectuer la tâche suivante :

• Configurer une instance de VM pour utiliser le SDK Python
• Se connecter au chat Gemini via un script Python
• Configurer le point de terminaison PSC pour se connecter aux Googleapis
• Vérifier le chemin de connectivité vers Googleais
• Configurer des entrées DNS manuelles

Configuration de l'environnement au rythme de chacun

1. Connectez-vous à la console Google Cloud, puis créez un projet ou réutilisez un projet existant. Si vous n'avez pas encore de compte Gmail ou Google Workspace, vous devez en créer un.

• Le nom du projet est le nom à afficher pour les participants au projet. Il s'agit d'une chaîne de caractères non utilisée par les API Google. Vous pourrez toujours la modifier.
• L'ID du projet est unique parmi tous les projets Google Cloud et non modifiable une fois défini. La console Cloud génère automatiquement une chaîne unique (en général, vous n'y accordez d'importance particulière). Dans la plupart des ateliers de programmation, vous devrez indiquer l'ID de votre projet (généralement identifié par PROJECT_ID). Si l'ID généré ne vous convient pas, vous pouvez en générer un autre de manière aléatoire. Vous pouvez également en spécifier un et voir s'il est disponible. Après cette étape, l'ID n'est plus modifiable et restera donc le même pour toute la durée du projet.
• Pour information, il existe une troisième valeur (le numéro de projet) que certaines API utilisent. Pour en savoir plus sur ces trois valeurs, consultez la documentation.

Attention : Un ID de projet est unique. Une fois que vous l'avez choisi, personne d'autre ne peut l'employer. Vous en êtes le seul utilisateur. Même si un projet est supprimé, son ID ne peut pas être réutilisé.

Remarque : Si vous utilisez un compte Gmail, vous pouvez conserver l'emplacement par défaut défini sur Aucune organisation. Si vous utilisez un compte Google Workspace, choisissez un emplacement qui ait du sens pour votre organisation.

2. Vous devez ensuite activer la facturation dans la console Cloud pour utiliser les ressources/API Cloud. L'exécution de cet atelier de programmation est très peu coûteuse, voire sans frais. Pour désactiver les ressources et éviter ainsi que des frais ne vous soient facturés après ce tutoriel, vous pouvez supprimer le projet ou les ressources que vous avez créées. Les nouveaux utilisateurs de Google Cloud peuvent participer au programme d'essai sans frais pour bénéficier d'un crédit de 300 $.

Démarrer Cloud Shell

Bien que Google Cloud puisse être utilisé à distance depuis votre ordinateur portable, nous allons nous servir de Google Cloud Shell pour cet atelier de programmation, un environnement de ligne de commande exécuté dans le cloud.

Dans la console Google Cloud, cliquez sur l'icône Cloud Shell dans la barre d'outils supérieure :

Le provisionnement et la connexion à l'environnement prennent quelques instants seulement. Une fois l'opération terminée, le résultat devrait ressembler à ceci :

Cette machine virtuelle contient tous les outils de développement nécessaires. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud, ce qui améliore nettement les performances du réseau et l'authentification. Vous pouvez effectuer toutes les tâches de cet atelier de programmation dans un navigateur. Vous n'avez rien à installer.

3. Tâche 1 : Configurer l'environnement avec Terraform

Nous allons créer un VPC personnalisé avec des règles de pare-feu et un sous-réseau. Ouvrez la console Cloud et sélectionnez le projet que vous utiliserez.

1. Ouvrez Cloud Shell en haut à droite de la console, assurez-vous que l'ID de projet correct s'affiche dans Cloud Shell, puis confirmez les invites pour autoriser l'accès.
2. Créer un dossier nommé "terraform-build" et le déplacer vers le dossier

mkdir terraform-build  && cd terraform-build

3. Créez un fichier main.tf et un fichier variable.tf.

touch main.tf variable.tf 

4. Accédez à la vue Éditeur Cloud Shell. Sélectionnez editor (éditeur), puis assurez-vous d'autoriser toutes les invites nécessaires pour que l'interface puisse se charger.
5. Une fois le fichier chargé, accédez à File > Open Folder (Fichier > Ouvrir le dossier), puis accédez à /home/votre-nom-utilisateur/terraform-build et sélectionnez Ok (OK) pour ouvrir le dossier dans l'éditeur.
6. Sélectionnez le fichier variable.tf et ajoutez ce qui suit. Remplacez le texte your-project-id-here par votre ID de projet réel entre guillemets.

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

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

7. Ouvrez ensuite le fichier main.tf. Nous allons ajouter du code Terraform pour effectuer diverses actions, comme expliqué ci-dessous.

Activer les API	resource "google_project_service" "default"
Créer un VPC nommé python-net	resource "google_compute_network" "default"
Ajouter un sous-réseau	resource "google_compute_subnetwork" "default"
Ajouter deux règles de pare-feu	resource "google_compute_firewall" "allow_icmp"resource "google_compute_firewall" "allow_ssh"

8. Copiez et collez le code suivant dans le fichier 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. Revenez dans le terminal Cloud Shell, assurez-vous d'être dans le répertoire cd terraform-build terraform-build, puis exécutez les commandes suivantes.

terraform init

Initialise le répertoire de travail. Cette étape télécharge les fournisseurs requis pour la configuration donnée.

terraform plan

Génère un plan d'exécution indiquant les actions effectuées par Terraform pour déployer votre infrastructure.

10. Pour créer les ressources, exécutez la commande terraform apply et saisissez yes.

Vérifiez votre configuration:vérifiez que votre environnement

1 VPC nommé python-net

1 sous-réseau

2 firewall-rules

4. Tâche 2 : Créer une passerelle NAT et des VM avec Terraform

Nous devons accorder un accès externe sortant à Internet. C'est pourquoi nous devons créer une passerelle Cloud NAT et l'associer.

1. Ouvrez Cloud Shell, accédez au dossier terraform-build et créez les fichiers suivants (trois au total). Nous les modifierons plus tard.

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

2. Passez à la vue de l'éditeur Cloud Shell, sélectionnez le fichier nat-vm.tf et ajoutez le code Terraform suivant. Une passerelle NAT et deux VM seront créées.

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. Passez au terminal Cloud Shell, assurez-vous d'être dans le dossier terraform-build et exécutez terraform plan. Vous verrez alors que quatre éléments seront ajoutés. Exécutez ensuite terraform apply et saisissez yes pour créer la passerelle NAT et deux VM.

Vérifiez votre configuration:vérifiez que votre environnement

1 passerelle NAT

1 routeur cloud

VM nommée py-vm1

VM nommée py-vm2

5. Tâche 3 : Configurer des VM et effectuer des tests

1. Accédez aux instances de VM. Sélectionnez la VM commençant par py-vm1. Sélectionnez SSH.
2. Une fois que vous êtes connecté en SSH à py-vm1,activez le mode root en saisissant sudo -i
3. Activez votre environnement venv :

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

4. Nous allons maintenant l'authentifier pour effectuer des tests plus tard. Exécutez la commande suivante dans la VM, puis appuyez sur y lorsque vous y êtes invité.

gcloud auth application-default login

5. Copiez ensuite l'URL qui apparaît au début de https://, ouvrez un nouvel onglet dans la fenêtre de navigateur de l'atelier et collez-la. Acceptez les requêtes.
6. Lorsque vous voyez la copie de sélection suivante, revenez à la session py-vm1 de la VM et, dans le champ Enter authorization code (Saisir le code d'autorisation), collez le code que vous avez copié et appuyez sur Entrée pour vous authentifier.

7. Faisons maintenant un test rapide pour voir si nous pouvons nous connecter à l'API Vertex Gemini. Elle utilise us-central1-aiplatform.googleapis.com. Nous allons donc envoyer un dig à cette adresse pour voir comment le trafic est acheminé.

dig us-central1-aiplatform.googleapis.com

8. Le résultat doit ressembler à ceci (l'adresse sera différente). Notez que le chemin d'accès s'effectue via des adresses IP publiques, car l'API est une API publique. NE COPIER PAS

; <<>> 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. Utilisons maintenant Python. Saisissez ipython pour activer l'interface ipython.

ipython

10. À présent, copiez et collez le texte suivant. Vous demandez à Gemini "Quelles sont les couleurs du logo Google" et "Quelle est la couleur du ciel". Remplacez enter-your-project-id-here par votre ID de projet entre guillemets.

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. Appuyez sur Entrée pour l'exécuter et voir le résultat.
12. Cette requête a accédé à Vertex via l'API publique.
13. Fermez la session SSH et continuons.

Remarque:Vous pouvez modifier la question de la requête.

Configurez maintenant py-vm2 avec les mêmes configurations.

14. Accédez aux instances de VM. Sélectionnez la VM commençant par py-vm2. Sélectionnez SSH.
15. Une fois connecté en SSH à py-vm2, activez l'utilisateur racine en saisissant **sudo -i**.
16. Activez votre environnement venv :

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

17. Authentifions-le maintenant pour effectuer des tests plus tard. Exécutez la commande suivante dans la VM :

gcloud auth application-default login

18. Copiez ensuite l'URL qui commence par https://, ouvrez un nouvel onglet dans la fenêtre de votre navigateur de laboratoire et collez l'URL. Acceptez les invites.
19. Lorsque vous voyez la copie de sélection suivante, revenez à la session py-vm2 de la VM et, dans le champ Enter authorization code (Saisissez le code d'autorisation), collez le code que vous avez copié et appuyez sur Entrée pour vous authentifier.

20. Faisons maintenant un test rapide pour voir si nous pouvons nous connecter à l'API Vertex Gemini. Cette commande enverra quatre pings à us-central1-aiplatform.googleapis.com afin que nous obtenions une réponse à partir de l'adresse publique de l'API.

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

21. Nous reviendrons ultérieurement pour tester cette VM. Fermez la session SSH et continuons.

6. Tâche 4 : Créer le point de terminaison PSC vers googleapis avec Terraform

Pour activer la connectivité privée à notre point de terminaison d'API Vertex, nous allons créer un point de terminaison Private Service Connect pour les API Google. Cela nous permettra d'utiliser une adresse IP privée que nous attribuerons pour acheminer le trafic vers les API Google dont nous avons besoin, dans ce cas Vertex.

1. Si ce n'est pas déjà fait, ouvrez Cloud Shell dans la vue de l'éditeur. Nous allons créer les éléments suivants:

• Créez une adresse IP pour le point de terminaison PSC 192.168.255.250 (resource "google_compute_global_address" "default")
• Créer un point de terminaison PSC pour les API Google (resource "google_compute_global_forwarding_rule" "default")

Ouvrez le fichier psc.tf dans le dossier terraform-build. Ajoutez le code suivant au fichier.

psc.tf de Terraform

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. Passez au terminal Cloud Shell et vérifiez que vous vous trouvez dans le dossier terraform-build. Ensuite, exécutez terraform init. Ensuite, exécutez terraform plan pour indiquer que deux éléments vont être ajoutés.
   Ensuite, exécutez terraform apply et saisissez yes pour créer l'adresse IP et le point de terminaison des API Google PSC.
3. Vérifier l'existence du point de terminaison

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

gcloud compute forwarding-rules describe pscvertexgemini --global

7. Tâche 5 : Vérifier la connectivité des points de terminaison via l'adresse IP

Connectez-vous à Gemini à l'aide du point de terminaison privé.

1. Accédez à l'instance de VM py-vm1. Sélectionner "SSH et SSH" dans la VM
2. Obtenez un accès root en saisissant sudo -i.
3. Nous allons simplement utiliser cette instance individuelle pour tester le point de terminaison PSC. Nous allons donc modifier le fichier hosts avec l'entrée suivante :

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

cat /etc/hosts

Remarque:Une entrée statique sera ajoutée pour mapper l'adresse us-central1-aiplatform.googleapis.com à l'adresse IP du point de terminaison PSC.

4. Vérifiez le chemin d'accès de la connectivité à us-central1-aiplatform.googleapis.com à l'aide de la commande ping. L'adresse IP que vous avez saisie dans les fichiers hôtes sera pinguée. Il s'agit d'un point de terminaison PSC, et vos pings échoueront.

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

5. Revenez dans la console et ouvrez une autre instance de l'instance de VM py-vm1. Sélectionnez SSH et connectez-vous en SSH à la VM.
6. Obtenez un accès root en saisissant sudo -i.
7. Exécutez la commande suivante pour afficher la connectivité dans un dump TCP.

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

8. Revenez maintenant à la première instance SSH de l'instance de VM py-vm1.
9. Activer l'environnement à l'aide de

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

10. Testons maintenant Python. Saisissez ipython pour activer l'interface ipython. Cette fois, le trafic transite par le point de terminaison PSC.

ipython

11. Copiez et collez le texte suivant. Vous demandez à Gemini Quelles sont toutes les couleurs du logo Google ? et Décris les chutes du Niagara. Remplacez enter-your-project-id-here par l'ID de votre projet entre guillemets.

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. Appuyez sur Entrée pour exécuter et voir le résultat.
13. Revenez à la deuxième instance de l'instance de VM py-vm1. Vous devriez voir le résultat de TCPDUMP. Vous verrez les entrées et les sorties avec les adresses IP de la VM, ainsi que l'adresse IP du point de terminaison PSC pour vous connecter à 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. Fermez toutes les sessions SSH à l'instance de VM py-vm1.

8. Tâche 6 : Créer une entrée DNS manuelle dans googleapis avec Terraform (facultatif)

Vous pouvez créer une entrée DNS manuelle pour faire pointer vers le point de terminaison PSC à l'aide du DNS privé. Cela affectera tous les réseaux que vous lui attribuerez.

1. Accédez à "Services réseau", puis sélectionnez "Cloud DNS".
2. Dans les zones, vous devriez voir une zone créée automatiquement pour Private Service Connect pour les API Google, avec le type de zone "Service Directory". Vous pouvez l'utiliser pour vous connecter au point de terminaison PSC au format **SERVICE-ENDPOINT.p.googleapis.com (par exemple : aiplatform-pscvertexgemini.p.googleapis.com).
3. Dans ce cas, nous souhaitons créer manuellement une entrée DNS privée. La configuration se présentera comme suit :

• Créez une zone DNS privée nommée "googleapis-private" pour "googleapis.com" et limitez-la au réseau "python-net".
• Ajoutez un enregistrement A pour mapper "googleapis.com" à l'adresse IP "192.168.255.250".
• Ajoutez un enregistrement CNAME pour rediriger tous les sous-domaines de "googleapis.com" (par exemple, www.googleapis.com) vers "googleapis.com".

4. Ouvrez Cloud Shell en mode Éditeur, si ce n'est pas déjà fait. Ouvrez le fichier dns.tf dans le dossier "terraform-build". Ajoutez le code suivant au fichier.

dns.tf Terraform

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. Accédez au terminal Cloud Shell et assurez-vous d'être dans le dossier terraform-build. Ensuite, exécutez terraform plan pour afficher les éléments à ajouter.
   Ensuite, exécutez terraform apply et saisissez yes pour créer l'entrée DNS privée.
6. Vous devriez voir une configuration avec un enregistrement A et un enregistrement CNAME comme indiqué ci-dessous (voir ).
7. Nous vérifions ensuite la connectivité avec ces modifications sur py-vm2.

9. Tâche 7 : Vérifier la connectivité du point de terminaison via l'adresse IP (facultatif)

Connectons-nous à Gemini à l'aide du point de terminaison privé.

Remarque:Aucune configuration manuelle n'est nécessaire sur la VM.

1. Accédez à l'instance de VM py-vm2. Sélectionner "SSH et SSH" dans la VM
2. Obtenez un accès root en saisissant sudo -i
3. Vérifiez le chemin d'accès de la connectivité à us-central1-aiplatform.googleapis.com à l'aide de la commande ping. L'adresse IP du DNS privé, l'enregistrement A pour googleapis, sera pinguée. Cette adresse IP est un point de terminaison PSC, et vos pings échoueront.

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

4. Vérifiez le chemin de connectivité avec un ping à l'aide de l'entrée DNS créée automatiquement pour les API Google PSC avec aiplatform-pscvertexgemini.p.googleapis.com. Il pointe vers l'adresse IP du point de terminaison PSC, et vos pings échoueront.

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

5. Vérifiez le chemin d'accès de la connectivité à us-central1-aiplatform.googleapis.com à l'aide de la commande dig. Il doit s'agir de l'adresse IP du point de terminaison PSC.

dig us-central1-aiplatform.googleapis.com

6. Revenez dans la console et ouvrez une autre instance de l'instance de VM py-vm2. Sélectionnez SSH et SSH dans la VM.
7. Obtenez un accès root en saisissant sudo -i
8. Exécutez la commande suivante pour afficher la connectivité dans un dump TCP

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

9. Revenez maintenant à la première instance SSH de l'instance de VM py-vm2.
10. Activez l'environnement à l'aide de

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

11. Testons maintenant Python. Saisissez ipython pour activer l'interface ipython.

ipython

12. À présent, copiez et collez le texte suivant. Demandez à Gemini "Quelles sont les couleurs du logo Google" et "Quelles sont les deux fonctionnalités de Gemini Pro". Remplacez enter-your-project-id-here par votre ID de projet entre guillemets.

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. Appuyez sur Entrée pour exécuter la requête et afficher le résultat.
14. Revenez à la deuxième instance de l'instance de VM py-vm2. Le résultat de l'opération TCPDUMP doit s'afficher. Vous remarquerez que l'adresse IP de la VM utilise l'adresse IP du point de terminaison PSC pour se connecter à us-central1-aiplatform.googleapis.com.

Fermez toutes les sessions SSH à l'instance de VM py-vm2.

10. Effectuer un nettoyage

1. Accédez à Cloud Shell, vérifiez que vous vous trouvez bien dans le répertoire terraform-build cd terraform-build, exécutez la commande terraform destroy suivante et saisissez yes. Toutes les ressources que vous avez créées dans votre projet avec Terraform seront supprimées.

11. Félicitations

Félicitations, vous êtes connecté à la discussion Vertex Gemini à la fois à l'aide de l'adresse API publique et de manière privée à l'aide du point de terminaison Private Service Connect pour les API Google. Cette fonctionnalité peut étendre la connectivité des API privées à votre environnement sur site/autre cloud connecté via (Interconnect, Cross-Cloud Interconnect et VPC).

Étapes suivantes et informations supplémentaires

Pour en savoir plus, consultez Mise en réseau Vertex AI.

Atelier de programmation : Accéder à Anthropic Claude sur Vertex AI avec le SDK Python via un point de terminaison Private Service Connect

Atelier suivant

Poursuivez votre quête avec Google Cloud et découvrez ces autres ateliers Google Cloud Skills Boost :

• Networking Fundamentals in Google Cloud
• Explorateur d'IA générative – Vertex AI