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 motif suivant.

Figure 1.

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 à Gemini Chat via un script Python
• Configurer le point de terminaison PSC pour se connecter à 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 le 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éez un dossier appelé "terraform-build" et déplacez-vous vers ce dossier.

mkdir terraform-build  && cd terraform-build

3. Créez des fichiers main.tf et variable.tf.

touch main.tf variable.tf 

4. Accédez à la vue Éditeur Cloud Shell. Sélectionnez Éditeur, puis assurez-vous d'autoriser 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, puis ajoutez les éléments suivants. 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, qui indique les actions que Terraform effectuera pour déployer votre infrastructure.

10. Pour créer les ressources, exécutez la commande terraform apply, puis saisissez yes pour l'exécuter.

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 Internet sortant externe. Créons donc une passerelle Cloud NAT et associons-la.

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 Éditeur Cloud Shell, sélectionnez le fichier nat-vm.tf, puis 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 connecté en SSH à py-vm1,activez l'utilisateur racine en saisissant sudo -i.
3. Activez votre environnement venv:

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

4. Authentifions-le maintenant 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 commence par https://, ouvrez un nouvel onglet dans la fenêtre de votre navigateur de laboratoire et collez l'URL. Acceptez les requêtes.
6. Lorsque l'invite de sélection de copie suivante s'affiche, revenez à la session de la VM py-vm1 et collez le code que vous avez copié dans Enter authorization code: (Saisissez le code d'autorisation). Appuyez sur Entrée pour vous authentifier.

7. Effectuons maintenant un test rapide pour voir si nous pouvons nous connecter à l'API Vertex Gemini, qui utilise us-central1-aiplatform.googleapis.com. Nous allons donc effectuer 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 passe par 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. Copiez et collez le texte suivant. Cela demande à Gemini Quelles sont toutes 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 exécuter la requête et afficher 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 remplacer la question de requête par une autre.

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 requêtes.
19. Lorsque l'invite de sélection de copie suivante s'affiche, revenez à la session de VM py-vm2 et collez le code que vous avez copié dans Enter authorization code: (Saisissez le code d'autorisation). Appuyez sur Entrée pour vous authentifier.

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

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

21. Nous reviendrons tester cette VM plus tard. 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. Ouvrez Cloud Shell en mode Éditeur, si ce n'est pas déjà fait. 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.

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. Accédez au terminal Cloud Shell et assurez-vous d'être dans le dossier terraform-build. Exécutez ensuite terraform init,puis terraform plan. Vous verrez alors que deux éléments sont ajoutés.
   Exécutez ensuite terraform apply et saisissez yes pour créer le point de terminaison des API Google IP et 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

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

1. Accédez à l'instance de VM py-vm1. Sélectionner SSH et se connecter en SSH à la VM
2. Obtenez un accès root en saisissant sudo -i.
3. Nous allons 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, qui mappera l'adresse us-central1-aiplatform.googleapis.com sur l'adresse IP du point de terminaison PSC.

4. Vérifiez le chemin de connectivité vers us-central1-aiplatform.googleapis.com à l'aide de la commande ping. L'adresse IP que vous avez saisie dans les fichiers hosts sera alors pinguée. Il s'agit d'un point de terminaison PSC. Vos pings ne fonctionneront pas.

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. Activez 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 transitera par le point de terminaison PSC.

ipython

11. Copiez et collez le texte suivant. Vous demandez à Gemini de répondre à Quelles sont toutes les couleurs du logo Google et Décris les chutes du Niagara. 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 = "Describe Niagara Falls"
print(get_chat_response(chat_session, prompt))

12. Appuyez sur Entrée pour exécuter la requête et afficher 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 "In" (Entrée) et "Out" (Sortie) 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 d'un 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 "Zones", vous devriez voir une zone créée automatiquement pour Private Service Connect pour les API Google, avec un annuaire de services de type zone. 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 sera la suivante :

• 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.

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. Accédez au terminal Cloud Shell et assurez-vous d'être dans le dossier terraform-build. Exécutez ensuite terraform plan pour afficher les éléments qui seront ajoutés.
   Exécutez ensuite 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 suit :
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 se connecter en SSH à la VM
2. Obtenez un accès root en saisissant sudo -i.
3. Vérifiez le chemin de connectivité vers 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. 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 ne seront pas acceptés.

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

5. Vérifiez le chemin de connectivité vers 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 connectez-vous en SSH à 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. Copiez et collez le texte suivant. Vous demandez à Gemini Quelles sont toutes les couleurs du logo Google et Quelles sont 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. Vous devriez voir le résultat de TCPDUMP. 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, assurez-vous d'être dans le répertoire terraform-build cd terraform-build, exécutez la commande suivante terraform destroy 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 maintenant connecté au chat 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 sur la 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:

• Principes de base de la mise en réseau dans Google Cloud
• Explorateur d'IA générative – Vertex AI