Accéder au chat Gemini 3 Pro à l'aide du SDK Python via un point de terminaison Private Service Connect

1. Présentation

L'API Vertex AI est accessible sur Internet. Toutefois, dans votre entreprise, vous pouvez souhaiter accéder à l'API Vertex AI de manière privée, sans passer par Internet. Dans cet atelier, vous allez d'abord

• Accéder à l'API Gemini 3 Pro via Vertex à l'aide du SDK Python
• Il s'exécutera sur une instance de VM.
• La connexion se fera via Cloud NAT à 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 seront une combinaison de Terraform, gcloud et de la console.

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

Figure 1.

2. Objectif

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

• Configurer une instance de VM pour utiliser le SDK Python
• Se connecter à Gemini Chat via un script Python
• Configurer un 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 ne possédez 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 allez utiliser.

1. Ouvrez Cloud Shell en haut à droite de la console. Assurez-vous que l'ID de projet correct s'affiche dans Cloud Shell et confirmez les éventuelles invites d'autorisation d'accès.
2. Créez un dossier appelé "terraform-build" et accédez-y.

mkdir terraform-build  && cd terraform-build

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

touch main.tf variable.tf 

4. Passez à la vue Éditeur Cloud Shell. Sélectionnez Éditeur et 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/your-user-name/terraform-build et sélectionnez OK pour ouvrir le dossier dans l'éditeur.
6. Sélectionnez le fichier variable.tf et ajoutez-y le code suivant. Remplacez le texte your-project-id-here par l'ID de votre projet 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 différentes actions, comme expliqué ci-dessous.

Activer les API	resource "google_project_service" "default"
Créer un VPC appelé 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 texte suivant dans le fichier 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"]
}

9. Revenez au terminal Cloud Shell, assurez-vous d'être dans le répertoire terraform-build cd terraform-build et 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 et saisissez yes.

Validez votre configuration : vérifiez que votre environnement contient

1 VPC appelé python-net

1 sous-réseau

2 règles de pare-feu

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

Nous devons accorder un accès externe sortant à Internet. 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. Cela créera une passerelle NAT et deux VM.

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
}

3. Passez au terminal Cloud Shell, assurez-vous d'être dans le dossier terraform-build, puis exécutez terraform plan. Vous verrez que quatre éléments seront ajoutés. Ensuite, exécutez terraform apply et saisissez yes pour créer la passerelle NAT et la VM.

Validez votre configuration : vérifiez que votre environnement contient

1 passerelle NAT

1 routeur cloud

VM nommée py-vm1

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

1. Accédez à "Instances de VM". Sélectionnez la VM commençant par py-vm1. Sélectionnez SSH.
2. Une fois que vous vous êtes connecté en SSH à py-vm1,activez l'accès root 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 du navigateur de l'atelier et collez l'URL. Acceptez les requêtes.
6. Lorsque le message suivant s'affiche, sélectionnez "Copier", revenez à la session de la VM py-vm1, puis collez le code copié dans Saisissez le code d'autorisation et appuyez sur Entrée pour vous authentifier.

7. Effectuons maintenant un test rapide pour voir si nous pouvons nous connecter à l'API Vertex. Celle-ci utilise *-aiplatform.googleapis.com. Nous allons donc effectuer un dig à cette adresse pour voir comment le trafic est acheminé.

dig *-aiplatform.googleapis.com

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

; <<>> 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

9. Utilisons maintenant Python. Saisissez ipython pour activer l'interface ipython.

ipython

10. Copiez et collez le texte suivant. Il s'agit de demander à Gemini Quelles sont les couleurs du logo Google ? et Quelle est la couleur du ciel ?

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?")

11. Appuyez deux fois sur Entrée pour exécuter la commande et afficher le résultat.
12. Cette requête a accédé à Vertex via l'API publique.
13. Fermez la session SSH et poursuivez.

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

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 de l'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 attribuons pour acheminer le trafic vers les API Google dont nous avons besoin, en l'occurrence 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. Passez au terminal Cloud Shell et assurez-vous d'être dans le dossier terraform-build. Exécutez ensuite terraform init. Vous verrez que deux éléments seront ajoutés.
    Exécutez ensuite terraform apply et saisissez yes pour créer le point de terminaison des API Google avec adresse IP et PSC.terraform plan
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 : Créer une entrée DNS manuelle pour googleapis avec Terraform

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

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 "Annuaire de services". Vous pouvez l'utiliser pour vous connecter au point de terminaison PSC au format **SERVICE-ENDPOINT.p.googleapis.com. 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. Passez 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,puis exécutez
   et saisissez yes pour créer l'entrée DNS privée.terraform apply
6. Vous devriez voir une configuration avec un enregistrement A et un CNAME comme ceci :
7. Nous allons ensuite vérifier la connectivité avec ces modifications sur py-vm1.

8. Tâche 6 : Vérifier la connectivité du point de terminaison via l'adresse IP

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-vm1. Sélectionnez SSH et connectez-vous en SSH à la VM
2. Obtenez l'accès root en saisissant sudo -i.
3. Vérifiez le chemin de connectivité vers aiplatform.googleapis.com à l'aide de la commande ping. Cela ping l'adresse IP dans le DNS privé, enregistrement A pour googleapis. Cette adresse IP est un point de terminaison PSC et vos pings échoueront.

ping -c 2 aiplatform.googleapis.com

4. Vérifiez le chemin de connectivité avec ping à l'aide de l'entrée DNS créée automatiquement pour les API Google PSC avec aiplatform-pscvertexgemini.p.googleapis.com. Cela 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 de connectivité vers aiplatform.googleapis.com à l'aide de la commande dig. Il doit s'agir de l'adresse IP du point de terminaison PSC.

dig aiplatform.googleapis.com

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

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

9. Revenez maintenant à la première instance SSH de l'instance de VM py-vm1.
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. Gemini répond aux questions En une phrase courte, résume ce qu'est un tokenizer dans le contexte de l'IA et Les baleines sont-elles géniales ou pas ?.

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?")

13. Appuyez deux fois sur Entrée pour exécuter la requête et afficher le résultat.
14. Revenez à la deuxième instance de VM py-vm1. 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 à aiplatform.googleapis.com.

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

9. Effectuer un nettoyage

1. Accédez à Cloud Shell et assurez-vous d'être dans le répertoire terraform-build cd terraform-build.
2. Exécutez terraform plan destroy pour afficher toutes les modifications qui seront apportées.

terraform plan -destroy

3. Exécutez ensuite la commande terraform destroy, puis saisissez yes. Toutes les ressources que vous avez créées dans votre projet avec Terraform seront supprimées.

terraform destroy 

10. Félicitations

Félicitations ! Vous vous êtes connecté à Vertex et avez utilisé Gemini 3 Pro via une adresse d'API publique et de manière privée à l'aide d'un 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 de 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

Continuez sur votre lancée avec Google Cloud et consultez ces autres ateliers Google Cloud Skills Boost :

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