Een praktische gids voor GCP Vertex AI Serverless Endpoints: Van nul tot productie

Zorg er eerst voor dat de Vertex AI API is ingeschakeld in uw project.

# Schakel de Vertex AI API in
gcloud services enable aiplatform.googleapis.com

Deze bewerking kan een minuut of twee duren om te voltooien.

In een echt project zou u uw eigen getrainde model gebruiken. Voor deze gids trainen we een speelgoed-sentimentclassificatie. Een veelvoorkomende fout die ik zie, is het afzonderlijk pickelen van een model en de preprocessor (zoals een tokenizer of vectorizer). Dit creëert een afhankelijkheidsnachtmerrie tijdens de implementatie. De juiste aanpak is om ze te combineren in een enkel sklearn.pipeline.Pipeline-object en dat te pickelen.

Maak een bestand genaamd 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

# Voorbeeldgegevens
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 voor positief, 0 voor negatief/neutraal

# Maak een scikit-learn pijplijn
# Dit bundelt de vectorizer en het model in een enkel artefact
pipeline = Pipeline([
    ('tfidf', TfidfVectorizer()),
    ('clf', LogisticRegression())
])

# Train de pijplijn
pipeline.fit(corpus, labels)

# Sla de hele pijplijn op in één bestand
with open('model.pkl', 'wb') as f:
    pickle.dump(pipeline, f)

print("Pijplijn opgeslagen als model.pkl")

Voer het script uit om uw model.pkl-bestand te genereren.

python3.12 create_model.py
# Verwachte uitvoer: Pijplijn opgeslagen als model.pkl

Ik sta op Infrastructuur als Code (IaC) voor alle cloudresources. Dit zorgt ervoor dat implementaties herhaalbaar, versiebeheerd en controleerbaar zijn. We gebruiken Terraform om ons Vertex AI Endpoint te definiëren.

Maak een main.tf-bestand:

# 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 = "De GCP project ID."
  type        = string
}

variable "region" {
  description = "De GCP regio voor 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  = "Beheerd serverloos eindpunt voor sentimentanalyse."
  project      = var.project_id
  location     = var.region

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

output "endpoint_resource_name" {
  description = "De volledige resourcenaam van het aangemaakte Vertex AI Endpoint."
  value       = google_vertex_ai_endpoint.sentiment_endpoint.name
}

Maak vervolgens een terraform.tfvars-bestand aan om uw projectspecifieke ID te bewaren. Vergeet niet de placeholder te vervangen door uw daadwerkelijke GCP-project-ID.

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

Initialiseer nu Terraform en pas de configuratie toe:

terraform init
terraform apply --auto-approve

Na een moment zal Terraform de volledige resourcenaam van uw endpoint uitvoeren. Noteer dit; u heeft het straks nodig.

Wil je hetzelfde patroon als in Stap 3, maar met europe-west4 (Nederland) als standaard, gebruik dan het onderstaande blok. europe-west1 (België) is een veelgebruikte alternatieve EU-westlocatie; zie Vertex AI-regio’s. Na terraform apply moeten GCS, Model Registry en de scripts in Stap 4–5 dezelfde regio gebruiken.

# ---------------------------------------------------------------------------
# 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
}

Met ons geprovisioneerde endpoint moeten we ons model registreren. We uploaden model.pkl naar een Google Cloud Storage (GCS) bucket en maken vervolgens een Model-resource in het Vertex AI Modelregister dat ernaar verwijst.

Maak eerst een GCS-bucket aan (als u er geen heeft) en upload uw model. Bucketnamen moeten wereldwijd uniek zijn.

# Vervang door uw unieke bucketnaam
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

Nu gebruiken we de Python SDK om dit artefact als een nieuwe modelversie te registreren. We verwijzen Vertex AI naar een voorgebouwde scikit-learn serving-container, die weet hoe een gepickled model moet worden geladen en geserveerd.

Maak een bestand genaamd upload_model.py:

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

# --- Configuratie ---
# Werk deze bij met uw eigen waarden
PROJECT_ID = os.getenv("GCLOUD_PROJECT")
REGION = "europe-west1"
BUCKET_NAME = "your-unique-model-bucket-ew1" # De bucket die u zojuist hebt gemaakt
MODEL_DISPLAY_NAME = "sentiment-analysis-model"
# --- Einde Configuratie ---

# Het GCS-pad naar de directory die het modelartefact bevat
ARTIFACT_URI = f"gs://{BUCKET_NAME}/sentiment_model/"

# Officiële Google voorgebouwde container voor scikit-learn 1.4
SERVING_CONTAINER_IMAGE = "europe-docker.pkg.dev/vertex-ai/prediction/sklearn-cpu.1-4:latest"

# Initialiseer de Vertex AI SDK
aiplatform.init(project=PROJECT_ID, location=REGION)

# Upload het model naar het Vertex AI Modelregister
model = aiplatform.Model.upload(

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

print(f"Model geüpload. Resourcenaam: {model.resource_name}")

# Om het model in de console te zien, bezoek:
# https://console.cloud.google.com/vertex-ai/models?project={PROJECT_ID}

Voer het script uit. Zorg ervoor dat u your-unique-model-bucket-ew1 vervangt door de bucketnaam die u hebt aangemaakt.

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

Dit registreert uw model en geeft de volledige resourcenaam weer, die we nodig hebben voor de laatste implementatiestap.

Dit is de laatste stap waarin alles samenkomt. We nemen het endpoint dat is gemaakt door Terraform en het model dat we zojuist hebben geregistreerd, en implementeren het model erop. Dit is de actie die Vertex AI activeert om de serverloze infrastructuur te provisioneren.

Maak deploy_model.py aan:

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

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

# Gebruik de endpoint resourcenaam van uw terraform-uitvoer
ENDPOINT_RESOURCE_NAME = f"projects/{PROJECT_ID}/locations/{REGION}/endpoints/your-endpoint-numeric-id"

# Gebruik de model resourcenaam van de upload_model.py-uitvoer
MODEL_RESOURCE_NAME = f"projects/{PROJECT_ID}/locations/{REGION}/models/your-model-numeric-id"

DEPLOYED_MODEL_DISPLAY_NAME = "sentiment-model-v1-prod"
# --- Einde Configuratie ---

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

# Krijg een verwijzing naar het bestaande endpoint
endpoint = aiplatform.Endpoint(ENDPOINT_RESOURCE_NAME)

print("Model implementeren naar endpoint...")
# Dit kan 10-15 minuten duren
endpoint.deploy(
    model=MODEL_RESOURCE_NAME,
    deployed_model_display_name=DEPLOYED_MODEL_DISPLAY_NAME,
    # Voor serverloos definieert u de 'vorm' van de machine, niet een specifiek type
    machine_type="n1-standard-2",
    min_replica_count=1, # Kan 0 zijn voor puur serverloos, 1 voor warm start
    max_replica_count=3,
    traffic_split={"0": 100}, # Stuur 100% van het verkeer naar dit nieuwe model
    sync=True, # Wacht tot de implementatie is voltooid
)

print(f"Model succesvol geïmplementeerd naar endpoint: {endpoint.display_name}")

Voordat u het uitvoert, moet u your-endpoint-numeric-id en your-model-numeric-id vervangen door de daadwerkelijke ID's uit de vorige stappen. U kunt deze vinden in uw terminaluitvoer of in de GCP-console.

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

Deze stap duurt enkele minuten, aangezien Vertex AI resources provisioneert, de containerimage ophaalt en het model implementeert. Heb geduld.

Zodra de implementatie is voltooid, is uw endpoint live. Laten we er wat voorbeeldgegevens naar sturen.

Maak predict_sentiment.py aan:

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

# --- Configuratie ---
PROJECT_ID = os.getenv("GCLOUD_PROJECT")
REGION = "europe-west1"
ENDPOINT_RESOURCE_NAME = f"projects/{PROJECT_ID}/locations/{REGION}/endpoints/your-endpoint-numeric-id"
# --- Einde Configuratie ---

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

# Krijg een verwijzing naar het endpoint
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."
]

# De predict-methode accepteert een lijst met instanties
# De voorgebouwde container retourneert een eenvoudige lijst met voorspellingen
response = endpoint.predict(instances=instances)

print("Voorspellingsreactie:")
print(response)

print("\n--- Resultaten ---")
for i, instance in enumerate(instances):
    prediction = response.predictions[i]
    sentiment = "Positief" if prediction == 1 else "Negatief/Neutraal"
    print(f"Invoer: '{instance}'\n  -> Voorspelling: {sentiment} ({prediction})\n")

Werk opnieuw your-endpoint-numeric-id bij en voer het script uit.

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

U zou de voorspellingen van het model voor uw voorbeeldinvoer moeten zien.

1. Toestemming geweigerd: Als u een 403 Permission 'aiplatform.endpoints.deployModel' denied ziet, ontbreekt bij uw gebruiker of serviceaccount de IAM-rol Vertex AI User (roles/aiplatform.user). Verleen deze en probeer het opnieuw.

2. Geïmplementeerd model is niet opgestart: Dit is een generieke fout, meestal betekent het dat de container in een crash-loop terechtkomt. De oorzaak ligt bijna altijd in de logs. Veelvoorkomende redenen zijn:

   • Pickle-versie komt niet overeen: De scikit-learn-versie die is gebruikt voor lokale training is incompatibel met de versie in de voorgebouwde container. Zorg ervoor dat ze overeenkomen.
   • Onjuist artefactpad: De artifact_uri in Model.upload moet verwijzen naar de GCS-directory die model.pkl bevat, niet naar het bestand zelf.

3. Kostenoverschrijdingen: Als u min_replica_count instelt op 1 of meer, wordt u 24/7 gefactureerd voor die rekenkracht, zelfs zonder verkeer. Voor ontwikkeling of niet-kritieke endpoints stelt u min_replica_count=0 in om de service volledig te laten schalen en inactieve kosten te vermijden.

• Serverloos is de standaard: Voor de meeste real-time inferentieworkloads begint u met Vertex AI Serverless Endpoints. Ze bieden de beste balans tussen prestaties, kosten en operationele eenvoud.
• IaC is niet onderhandelbaar: Provisioneer kernresources zoals endpoints altijd met Terraform. Dit biedt een herhaalbare, controleerbare basis voor uw MLOps-platform.
• Verpak modellen correct: Gebruik tools zoals de Pipeline van scikit-learn om pre-processing en modelleringsstappen te bundelen in een enkel, draagbaar artefact. Dit vereenvoudigt de implementatie drastisch.
• Beheer uw Endpoints: Gebruik labels om kosten en eigendom bij te houden. Stel min_replica_count=0 in voor niet-productieworkloads om de uitgaven te beheren.

Met een geïmplementeerd endpoint is de volgende stap om het te integreren in een echte applicatie. Daarnaast kunt u meer geavanceerde functies verkennen, zoals:

• Verkeerssplitsing: Implementeer een nieuwe modelversie naar hetzelfde endpoint en verschuif geleidelijk verkeer om A/B-tests of canary releases uit te voeren.
• Vertex AI Explainability: Integreer model-verklaarbaarheid om te begrijpen waarom uw model bepaalde voorspellingen doet.
• CI/CD-automatisering: Bouw een pijplijn in Cloud Build of GitHub Actions om automatisch nieuwe modelversies te trainen, registreren en implementeren bij codewijzigingen.

Voor een diepere duik in de bredere implicaties van beheerde AI-infrastructuur, kunt u de Technische analyse van de halfgeleidersector op Clear Signals bekijken.

• Complete broncode: U vindt de volledige code en Terraform-configuraties die in deze gids zijn gebruikt in [link naar een openbare GitHub-repository met de complete broncode].
• Officiële GCP-voorbeelden: Voor meer geavanceerde use cases is de officiële GoogleCloudPlatform/vertex-ai-samples-repository op GitHub een uitstekende bron.