Un guide pratique des points de terminaison sans serveur Vertex AI de GCP : de zéro à la production

Tout d'abord, assurez-vous que l'API Vertex AI est activée dans votre projet.

# Activer l'API Vertex AI
gcloud services enable aiplatform.googleapis.com

Cette opération peut prendre une minute ou deux.

Dans un projet réel, vous apporteriez votre propre modèle entraîné. Pour ce guide, nous entraînerons un classifieur de sentiment jouet. Une erreur courante que je vois est de sérialiser un modèle et son préprocesseur (comme un tokeniseur ou un vectoriseur) séparément. Cela crée un cauchemar de dépendances lors du déploiement. L'approche correcte consiste à les combiner en un seul objet sklearn.pipeline.Pipeline et à le sérialiser.

Créez un fichier nommé create_model.py :

# create_model.py
import pickle
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline

# Données d'échantillon
corpus = [
    "I love this product, it's amazing!",
    "This is terrible, I hate it.",
    "It's okay, nothing special.",
    "Absolutely fantastic experience."
]
labels = [1, 0, 0, 1]  # 1 pour positif, 0 pour négatif/neutre

# Créer un pipeline scikit-learn
# Cela regroupe le vectoriseur et le modèle en un seul artefact
pipeline = Pipeline([
    ('tfidf', TfidfVectorizer()),
    ('clf', LogisticRegression())
])

# Entraîner le pipeline
pipeline.fit(corpus, labels)

# Enregistrer le pipeline entier dans un seul fichier
with open('model.pkl', 'wb') as f:
    pickle.dump(pipeline, f)

print("Pipeline enregistré sous model.pkl")

Exécutez le script pour générer votre fichier model.pkl.

python3.12 create_model.py
# Résultat attendu : Pipeline enregistré sous model.pkl

J'insiste sur l'Infrastructure as Code (IaC) pour toutes les ressources cloud. Cela garantit que les déploiements sont répétables, versionnés et auditables. Nous utiliserons Terraform pour définir notre point de terminaison Vertex AI.

Créez un fichier main.tf :

# main.tf
terraform {
  required_providers {
    google = {
      source  = "hashicorp/google"
      version = ">= 4.50.0"
    }
  }
}

provider "google" {
  project = var.project_id
  region  = var.region
}

variable "project_id" {
  description = "The GCP project ID."
  type        = string
}

variable "region" {
  description = "The GCP region for Vertex AI resources."
  type        = string
  default     = "europe-west1"
}

resource "google_vertex_ai_endpoint" "sentiment_endpoint" {
  name         = "sentiment-analysis-endpoint"
  display_name = "Sentiment Analysis Serverless Endpoint"
  description  = "Managed serverless endpoint for sentiment analysis."
  project      = var.project_id
  location     = var.region

  labels = {
    environment = "production"
    service     = "sentiment-analysis"
  }
}

output "endpoint_resource_name" {
  description = "The full resource name of the created Vertex AI Endpoint."
  value       = google_vertex_ai_endpoint.sentiment_endpoint.name
}

Ensuite, créez un fichier terraform.tfvars pour contenir votre ID spécifique au projet. N'oubliez pas de remplacer le paramètre fictif par votre véritable ID de projet GCP.

# terraform.tfvars
project_id = "your-gcp-project-id"

Maintenant, initialisez Terraform et appliquez la configuration :

terraform init
terraform apply --auto-approve

Après un moment, Terraform affichera le nom complet de la ressource de votre point de terminaison. Notez-le ; vous en aurez besoin sous peu.

Pour reprendre le même schéma qu’à l’étape 3 en fixant par défaut europe-west4 (Pays-Bas), utilisez le bloc ci-dessous. europe-west1 (Belgique) est une autre option courante — voir les régions Vertex AI. Après terraform apply, gardez la même valeur de région pour le bucket GCS, l’import dans le Model Registry et les scripts des étapes 4–5.

# ---------------------------------------------------------------------------
# Vertex AI online prediction endpoint — EU West (default: europe-west4)
# Locations: https://cloud.google.com/vertex-ai/docs/general/locations
# Provider: hashicorp/google — same pattern as Step 3 in this article.
# Upload and deploy the model (Steps 4–5) in the SAME region.
# ---------------------------------------------------------------------------

terraform {
  required_version = ">= 1.5.0"
  required_providers {
    google = {
      source  = "hashicorp/google"
      version = ">= 4.50.0"
    }
  }
}

provider "google" {
  project = var.project_id
  region  = var.region
}

variable "project_id" {
  description = "The GCP project ID."
  type        = string
}

variable "region" {
  description = "Vertex AI region (EU West). Default europe-west4 (Netherlands); europe-west1 (Belgium) is a common alternative."
  type        = string
  default     = "europe-west4"
}

resource "google_vertex_ai_endpoint" "sentiment_endpoint_eu" {
  name         = "sentiment-analysis-endpoint-euw4"
  display_name = "Sentiment Analysis Serverless Endpoint (EU)"
  description  = "Managed Vertex AI endpoint — EU West module (Terraform)."
  project      = var.project_id
  location     = var.region

  labels = {
    environment = "production"
    service     = "sentiment-analysis"
    eu_module   = "europe-west4"
  }
}

output "endpoint_resource_name" {
  description = "Full resource name of the Vertex AI endpoint (use in SDK / gcloud deploy steps)."
  value       = google_vertex_ai_endpoint.sentiment_endpoint_eu.name
}

Une fois notre point de terminaison provisionné, nous devons enregistrer notre modèle. Nous téléchargerons model.pkl vers un bucket Google Cloud Storage (GCS), puis créerons une ressource Model dans le Registre de modèles Vertex AI qui y pointera.

Tout d'abord, créez un bucket GCS (si vous n'en avez pas) et téléchargez votre modèle. Les noms de buckets doivent être globalement uniques.

# Remplacer par le nom unique de votre bucket
BUCKET_NAME="your-unique-model-bucket-ew1"
PROJECT_ID=$(gcloud config get-value project)

gcloud storage buckets create gs://${BUCKET_NAME} --project=${PROJECT_ID} --location=europe-west1
gcloud storage cp model.pkl gs://${BUCKET_NAME}/sentiment_model/model.pkl

Maintenant, nous utiliserons le SDK Python pour enregistrer cet artefact en tant que nouvelle version de modèle. Nous indiquerons à Vertex AI un conteneur de service scikit-learn pré-construit, qui sait comment charger et servir un modèle sérialisé.

Créez un fichier nommé upload_model.py :

# upload_model.py
import os
from google.cloud import aiplatform

# --- Configuration ---
# Veuillez mettre à jour ces valeurs avec les vôtres
PROJECT_ID = os.getenv("GCLOUD_PROJECT")
REGION = "europe-west1"
BUCKET_NAME = "your-unique-model-bucket-ew1" # Le bucket que vous venez de créer
MODEL_DISPLAY_NAME = "sentiment-analysis-model"
# --- Fin de la configuration ---

# Le chemin GCS vers le répertoire contenant l'artefact du modèle
ARTIFACT_URI = f"gs://{BUCKET_NAME}/sentiment_model/"

# Conteneur pré-construit officiel de Google pour scikit-learn 1.4
SERVING_CONTAINER_IMAGE = "europe-docker.pkg.dev/vertex-ai/prediction/sklearn-cpu.1-4:latest"

# Initialiser le SDK Vertex AI
aiplatform.init(project=PROJECT_ID, location=REGION)

# Télécharger le modèle vers le Registre de modèles Vertex AI
model = aiplatform.Model.upload(

    display_name=MODEL_DISPLAY_NAME,
    artifact_uri=ARTIFACT_URI,
    serving_container_image_uri=SERVING_CONTAINER_IMAGE,
)

print(f"Modèle téléchargé. Nom de la ressource : {model.resource_name}")

# Pour voir le modèle dans la console, visitez :
# https://console.cloud.google.com/vertex-ai/models?project={PROJECT_ID}

Exécutez le script. Assurez-vous de remplacer your-unique-model-bucket-ew1 par le nom du bucket que vous avez créé.

export GCLOUD_PROJECT=$(gcloud config get-value project)
python3.12 upload_model.py

Cela enregistrera votre modèle et affichera son nom complet de ressource, dont nous aurons besoin pour l'étape finale de déploiement.

C'est l'étape finale où tout se met en place. Nous prendrons le point de terminaison créé par Terraform et le modèle que nous venons d'enregistrer, et déploierons le modèle sur celui-ci. C'est cette action qui déclenche le provisionnement de l'infrastructure sans serveur par Vertex AI.

Créez deploy_model.py :

# deploy_model.py
import os
from google.cloud import aiplatform

# --- Configuration ---
PROJECT_ID = os.getenv("GCLOUD_PROJECT")
REGION = "europe-west1"

# Utiliser le nom de ressource du point de terminaison de votre sortie terraform
ENDPOINT_RESOURCE_NAME = f"projects/{PROJECT_ID}/locations/{REGION}/endpoints/your-endpoint-numeric-id"

# Utiliser le nom de ressource du modèle de la sortie de upload_model.py
MODEL_RESOURCE_NAME = f"projects/{PROJECT_ID}/locations/{REGION}/models/your-model-numeric-id"

DEPLOYED_MODEL_DISPLAY_NAME = "sentiment-model-v1-prod"
# --- Fin de la configuration ---

aiplatform.init(project=PROJECT_ID, location=REGION)

# Obtenir une référence au point de terminaison existant
endpoint = aiplatform.Endpoint(ENDPOINT_RESOURCE_NAME)

print("Déploiement du modèle vers le point de terminaison...")
# Cela peut prendre 10-15 minutes
endpoint.deploy(
    model=MODEL_RESOURCE_NAME,
    deployed_model_display_name=DEPLOYED_MODEL_DISPLAY_NAME,
    # Pour le sans serveur, vous définissez la 'forme' de la machine, pas un type spécifique
    machine_type="n1-standard-2",
    min_replica_count=1, # Peut être 0 pour du pure sans serveur, 1 pour un démarrage à chaud
    max_replica_count=3,
    traffic_split={"0": 100}, # Envoyer 100% du trafic vers ce nouveau modèle
    sync=True, # Attendre la fin du déploiement
)

print(f"Modèle déployé avec succès sur le point de terminaison : {endpoint.display_name}")

Avant d'exécuter, vous devez remplacer your-endpoint-numeric-id et your-model-numeric-id par les ID réels des étapes précédentes. Vous pouvez les trouver dans la sortie de votre terminal ou dans la console GCP.

export GCLOUD_PROJECT=$(gcloud config get-value project)
python3.12 deploy_model.py

Cette étape prend plusieurs minutes car Vertex AI provisionne les ressources, télécharge l'image du conteneur et déploie le modèle. Soyez patient.

Une fois le déploiement terminé, votre point de terminaison est actif. Envoyons-lui quelques données d'échantillon.

Créez predict_sentiment.py :

# predict_sentiment.py
import os
from google.cloud import aiplatform

# --- Configuration ---
PROJECT_ID = os.getenv("GCLOUD_PROJECT")
REGION = "europe-west1"
ENDPOINT_RESOURCE_NAME = f"projects/{PROJECT_ID}/locations/{REGION}/endpoints/your-endpoint-numeric-id"
# --- Fin de la configuration ---

aiplatform.init(project=PROJECT_ID, location=REGION)

# Obtenir une référence au point de terminaison
endpoint = aiplatform.Endpoint(ENDPOINT_RESOURCE_NAME)

instances = [
    "This service is incredible, highly recommend!",
    "I'm very disappointed with the slow response.",
    "The food was average, nothing to write home about."
]

# La méthode predict prend une liste d'instances
# Le conteneur pré-construit renvoie une simple liste de prédictions
response = endpoint.predict(instances=instances)

print("Réponse de prédiction :")
print(response)

print("\n--- Résultats ---")
for i, instance in enumerate(instances):
    prediction = response.predictions[i]
    sentiment = "Positive" if prediction == 1 else "Négatif/Neutre"
    print(f"Entrée : '{instance}'\n  -> Prédiction : {sentiment} ({prediction})\n")

Encore une fois, mettez à jour your-endpoint-numeric-id et exécutez le script.

export GCLOUD_PROJECT=$(gcloud config get-value project)
python3.12 predict_sentiment.py

Vous devriez voir les prédictions du modèle pour vos entrées d'échantillon.

1. Permission refusée : Si vous voyez une erreur 403 Permission 'aiplatform.endpoints.deployModel' denied, votre utilisateur ou votre compte de service ne dispose pas du rôle IAM Vertex AI User (roles/aiplatform.user). Accordez-le, puis réessayez.

2. Le modèle déployé n'a pas démarré : Il s'agit d'une erreur générique, signifiant généralement que le conteneur redémarre en boucle. La cause se trouve presque toujours dans les journaux. Les raisons courantes incluent :

   • Incompatibilité de version de Pickle : La version de scikit-learn utilisée pour l'entraînement local est incompatible avec la version à l'intérieur du conteneur pré-construit. Assurez-vous qu'elles correspondent.
   • Chemin d'artefact incorrect : L'artifact_uri dans Model.upload doit pointer vers le répertoire GCS contenant model.pkl, et non le fichier lui-même.

3. Dépassements de coûts : Si vous définissez min_replica_count sur 1 ou plus, vous serez facturé pour ce calcul 24h/24 et 7j/7, même sans trafic. Pour le développement ou les points de terminaison non critiques, définissez min_replica_count=0 pour permettre au service de se réduire complètement et d'éviter les coûts d'inactivité.

• Le sans serveur est la norme : Pour la plupart des charges de travail d'inférence en temps réel, commencez par les points de terminaison sans serveur Vertex AI. Ils offrent le meilleur équilibre entre performances, coûts et simplicité opérationnelle.
• L'IaC est non-négociable : Provisionnez toujours les ressources principales comme les points de terminaison avec Terraform. Cela fournit une base répétable et auditable pour votre plateforme MLOps.
• Empaqueter les modèles correctement : Utilisez des outils comme scikit-learn's Pipeline pour regrouper les étapes de pré-traitement et de modélisation dans un seul artefact portable. Cela simplifie considérablement le déploiement.
• Gérer vos points de terminaison : Utilisez des étiquettes pour suivre les coûts et la propriété. Définissez min_replica_count=0 pour les charges de travail non-production afin de gérer les dépenses.

Avec un point de terminaison déployé, la prochaine étape est de l'intégrer dans une application réelle. Au-delà de cela, vous pouvez explorer des fonctionnalités plus avancées comme :

• Répartition du trafic : Déployez une nouvelle version du modèle sur le même point de terminaison et déplacez progressivement le trafic pour effectuer des tests A/B ou des déploiements canaris.
• Explicabilité de Vertex AI : Intégrez l'explicabilité du modèle pour comprendre pourquoi votre modèle fait certaines prédictions.
• Automatisation CI/CD : Construisez un pipeline dans Cloud Build ou GitHub Actions pour entraîner, enregistrer et déployer automatiquement de nouvelles versions de modèles suite à des modifications de code.

Pour une analyse plus approfondie des implications plus larges de l'infrastructure d'IA gérée, vous pourriez consulter l'Analyse technique du secteur des semi-conducteurs sur Clear Signals.

• Code source complet : Vous pouvez trouver le code complet et les configurations Terraform utilisés dans ce guide sur [lien vers un dépôt GitHub public avec le code source complet].
• Exemples officiels GCP : Pour des cas d'utilisation plus avancés, le dépôt officiel GoogleCloudPlatform/vertex-ai-samples sur GitHub est une excellente ressource.