Déployer et inférer Gemma à l'aide de Model Garden et de points de terminaison Vertex AI compatibles avec les GPU

Dans ce tutoriel, vous utilisez Model Garden pour déployer le modèle ouvert Gemma 1B sur un point de terminaison Vertex AI basé sur un GPU. Vous devez déployer un modèle sur un point de terminaison avant de pouvoir utiliser ce modèle pour livrer des prédictions en ligne. Le déploiement d'un modèle associe des ressources physiques au modèle afin qu'il puisse générer des prédictions en ligne avec une faible latence.

Après avoir déployé le modèle Gemma 1B, vous pouvez exécuter l'inférence du modèle entraîné à l'aide de PredictionServiceClient pour obtenir des prédictions en ligne. Les prédictions en ligne sont le résultat de requêtes synchrones adressées à un modèle déployé sur un point de terminaison.

Déployer Gemma à l'aide de Model Garden

Vous pouvez déployer Gemma 1B à l'aide de sa fiche dans la console Google Cloud ou de façon programmatique.

Pour en savoir plus sur la configuration du SDK Google Gen AI ou de la Google Cloud CLI, consultez la présentation du SDK Google Gen AI ou Installer Google Cloud CLI.

Python

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'API Python.

  1. Listez les modèles que vous pouvez déployer et enregistrez l'ID de celui que vous voulez déployer. Vous pouvez éventuellement lister les modèles Hugging Face compatibles dans Model Garden et même les filtrer par nom de modèle. La sortie n'inclut aucun modèle réglé.

    
import vertexai
from vertexai import model_garden

# TODO(developer): Update and un-comment below lines
# PROJECT_ID = "your-project-id"
vertexai.init(project=PROJECT_ID, location="us-central1")

# List deployable models, optionally list Hugging Face models only or filter by model name.
deployable_models = model_garden.list_deployable_models(list_hf_models=False, model_filter="gemma")
print(deployable_models)
# Example response:
# ['google/gemma2@gemma-2-27b','google/gemma2@gemma-2-27b-it', ...]

  2. Affichez les spécifications de déploiement d'un modèle à l'aide de son ID obtenu à l'étape précédente. Vous pouvez afficher le type de machine, le type d'accélérateur et l'URI de l'image de conteneur que Model Garden a validés pour un modèle particulier.

    
import vertexai
from vertexai import model_garden

# TODO(developer): Update and un-comment below lines
# PROJECT_ID = "your-project-id"
# model = "google/gemma3@gemma-3-1b-it"
vertexai.init(project=PROJECT_ID, location="us-central1")

# For Hugging Face modelsm the format is the Hugging Face model name, as in
# "meta-llama/Llama-3.3-70B-Instruct".
# Go to https://console.cloud.google.com/vertex-ai/model-garden to find all deployable
# model names.

model = model_garden.OpenModel(model)
deploy_options = model.list_deploy_options()
print(deploy_options)
# Example response:
# [
#   dedicated_resources {
#     machine_spec {
#       machine_type: "g2-standard-12"
#       accelerator_type: NVIDIA_L4
#       accelerator_count: 1
#     }
#   }
#   container_spec {
#     ...
#   }
#   ...
# ]

  3. Déployer un modèle sur un point de terminaison Model Garden utilise la configuration de déploiement par défaut, sauf si vous spécifiez un argument et des valeurs supplémentaires.

    
import vertexai
from vertexai import model_garden

# TODO(developer): Update and un-comment below lines
# PROJECT_ID = "your-project-id"
vertexai.init(project=PROJECT_ID, location="us-central1")

open_model = model_garden.OpenModel("google/gemma3@gemma-3-12b-it")
endpoint = open_model.deploy(
    machine_type="g2-standard-48",
    accelerator_type="NVIDIA_L4",
    accelerator_count=4,
    accept_eula=True,
)

# Optional. Run predictions on the deployed endoint.
# endpoint.predict(instances=[{"prompt": "What is Generative AI?"}])

gcloud

Avant de commencer, spécifiez un projet de quota pour exécuter les commandes suivantes. Les commandes que vous exécutez sont comptabilisées dans les quotas de ce projet. Pour en savoir plus, consultez Définir le projet de quota.

  1. Listez les modèles que vous pouvez déployer en exécutant la commande gcloud ai model-garden models list. Cette commande liste tous les ID de modèle et ceux que vous pouvez déployer vous-même.

    gcloud ai model-garden models list --model-filter=gemma

    Dans la sortie, recherchez l'ID du modèle à déployer. L'exemple suivant montre une sortie abrégée.

    MODEL_ID                                      CAN_DEPLOY  CAN_PREDICT
google/gemma2@gemma-2-27b                     Yes         No
google/gemma2@gemma-2-27b-it                  Yes         No
google/gemma2@gemma-2-2b                      Yes         No
google/gemma2@gemma-2-2b-it                   Yes         No
google/gemma2@gemma-2-9b                      Yes         No
google/gemma2@gemma-2-9b-it                   Yes         No
google/gemma3@gemma-3-12b-it                  Yes         No
google/gemma3@gemma-3-12b-pt                  Yes         No
google/gemma3@gemma-3-1b-it                   Yes         No
google/gemma3@gemma-3-1b-pt                   Yes         No
google/gemma3@gemma-3-27b-it                  Yes         No
google/gemma3@gemma-3-27b-pt                  Yes         No
google/gemma3@gemma-3-4b-it                   Yes         No
google/gemma3@gemma-3-4b-pt                   Yes         No
google/gemma3n@gemma-3n-e2b                   Yes         No
google/gemma3n@gemma-3n-e2b-it                Yes         No
google/gemma3n@gemma-3n-e4b                   Yes         No
google/gemma3n@gemma-3n-e4b-it                Yes         No
google/gemma@gemma-1.1-2b-it                  Yes         No
google/gemma@gemma-1.1-2b-it-gg-hf            Yes         No
google/gemma@gemma-1.1-7b-it                  Yes         No
google/gemma@gemma-1.1-7b-it-gg-hf            Yes         No
google/gemma@gemma-2b                         Yes         No
google/gemma@gemma-2b-gg-hf                   Yes         No
google/gemma@gemma-2b-it                      Yes         No
google/gemma@gemma-2b-it-gg-hf                Yes         No
google/gemma@gemma-7b                         Yes         No
google/gemma@gemma-7b-gg-hf                   Yes         No
google/gemma@gemma-7b-it                      Yes         No
google/gemma@gemma-7b-it-gg-hf                Yes         No

    La sortie n'inclut aucun modèle réglé ni modèle Hugging Face. Pour afficher les modèles Hugging Face compatibles, ajoutez le flag --can-deploy-hugging-face-models.

  2. Pour afficher les spécifications de déploiement d'un modèle, exécutez la commande gcloud ai model-garden models list-deployment-config. Vous pouvez afficher le type de machine, le type d'accélérateur et l'URI de l'image de conteneur que Model Garden accepte pour un modèle particulier.

    gcloud ai model-garden models list-deployment-config \
    --model=MODEL_ID

    Remplacez MODEL_ID par l'ID du modèle de la commande list précédente, par exemple google/gemma@gemma-2b ou stabilityai/stable-diffusion-xl-base-1.0.

  3. Déployez un modèle sur un point de terminaison en exécutant la commande gcloud ai model-garden models deploy. Model Garden génère un nom à afficher pour votre point de terminaison et utilise la configuration de déploiement par défaut, sauf si vous spécifiez un argument et des valeurs supplémentaires.

    Pour exécuter la commande de manière asynchrone, incluez le flag --asynchronous.

    gcloud ai model-garden models deploy \
    --model=MODEL_ID \
    [--machine-type=MACHINE_TYPE] \
    [--accelerator-type=ACCELERATOR_TYPE] \
    [--endpoint-display-name=ENDPOINT_NAME] \
    [--hugging-face-access-token=HF_ACCESS_TOKEN] \
    [--reservation-affinity reservation-affinity-type=any-reservation] \
    [--reservation-affinity reservation-affinity-type=specific-reservation, key="compute.googleapis.com/reservation-name", values=RESERVATION_RESOURCE_NAME] \
    [--asynchronous]

    Remplacez les espaces réservés suivants :

    • MODEL_ID : ID du modèle de la commande list précédente. Pour les modèles Hugging Face, utilisez le format d'URL de modèle Hugging Face, tel que stabilityai/stable-diffusion-xl-base-1.0.
    • MACHINE_TYPE : définit l'ensemble de ressources à déployer pour votre modèle, par exemple g2-standard-4.
    • ACCELERATOR_TYPE : spécifie les accélérateurs à ajouter à votre déploiement pour améliorer les performances lorsque vous utilisez des charges de travail intensives, telles que NVIDIA_L4.
    • ENDPOINT_NAME : nom du point de terminaison Vertex AI déployé.
    • HF_ACCESS_TOKEN : pour les modèles Hugging Face, si l'accès au modèle est restreint, fournissez un jeton d'accès.
    • RESERVATION_RESOURCE_NAME : pour utiliser une réservation Compute Engine spécifique, spécifiez le nom de votre réservation. Si vous spécifiez une réservation spécifique, vous ne pouvez pas spécifier any-reservation.

    La sortie inclut la configuration de déploiement utilisée par Model Garden, l'ID de point de terminaison et l'ID d'opération de déploiement, que vous pouvez utiliser pour vérifier l'état du déploiement.

    Using the default deployment configuration:
 Machine type: g2-standard-12
 Accelerator type: NVIDIA_L4
 Accelerator count: 1

The project has enough quota. The current usage of quota for accelerator type NVIDIA_L4 in region us-central1 is 0 out of 28.

Deploying the model to the endpoint. To check the deployment status, you can try one of the following methods:
1) Look for endpoint `ENDPOINT_DISPLAY_NAME` at the [Vertex AI] -> [Online prediction] tab in Cloud Console
2) Use `gcloud ai operations describe OPERATION_ID --region=LOCATION` to find the status of the deployment long-running operation

  4. Pour afficher les détails de votre déploiement, exécutez la commande gcloud ai endpoints list --list-model-garden-endpoints-only :

    gcloud ai endpoints list --list-model-garden-endpoints-only \
    --region=LOCATION_ID

    Remplacez LOCATION_ID par la région dans laquelle vous avez déployé le modèle.

    La sortie inclut tous les points de terminaison créés à partir de Model Garden, ainsi que des informations telles que l'ID du point de terminaison, son nom et s'il est associé à un modèle déployé. Pour trouver votre déploiement, recherchez le nom du point de terminaison renvoyé par la commande précédente.

REST

Listez tous les modèles déployables, puis obtenez l'ID du modèle à déployer. Vous pouvez ensuite déployer le modèle avec sa configuration et son point de terminaison par défaut. Vous pouvez également choisir de personnaliser votre déploiement, par exemple en définissant un type de machine spécifique ou en utilisant un point de terminaison dédié.

Lister les modèles que vous pouvez déployer

Avant d'utiliser les données de requête, effectuez les remplacements suivants :

  • PROJECT_ID : ID de votre projet Google Cloud .
  • QUERY_PARAMETERS : pour lister les modèles Model Garden, ajoutez ces paramètres de requête listAllVersions=True&filter=can_deploy(true). Pour lister les modèles Hugging Face, définissez le filtre sur alt=json&is_hf_wildcard(true)+AND+labels.VERIFIED_DEPLOYMENT_CONFIG%3DVERIFIED_DEPLOYMENT_SUCCEED&listAllVersions=True.

Méthode HTTP et URL : 

GET https://us-central1-aiplatform.googleapis.com/v1/publishers/*/models?QUERY_PARAMETERS

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Exécutez la commande suivante :

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "x-goog-user-project: PROJECT_ID" \
     "https://us-central1-aiplatform.googleapis.com/v1/publishers/*/models?QUERY_PARAMETERS"

PowerShell

Exécutez la commande suivante :

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "PROJECT_ID" }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://us-central1-aiplatform.googleapis.com/v1/publishers/*/models?QUERY_PARAMETERS" | Select-Object -Expand Content

Vous recevez une réponse JSON de ce type :

{
  "publisherModels": [
    {
      "name": "publishers/google/models/gemma3",
      "versionId": "gemma-3-1b-it",
      "openSourceCategory": "GOOGLE_OWNED_OSS_WITH_GOOGLE_CHECKPOINT",
      "supportedActions": {
        "openNotebook": {
          "references": {
            "us-central1": {
              "uri": "https://colab.research.google.com/github/GoogleCloudPlatform/vertex-ai-samples/blob/main/notebooks/community/model_garden/model_garden_gradio_streaming_chat_completions.ipynb"
            }
          },
          "resourceTitle": "Notebook",
          "resourceUseCase": "Chat Completion Playground",
          "resourceDescription": "Chat with deployed Gemma 2 endpoints via Gradio UI."
        },
        "deploy": {
          "modelDisplayName": "gemma-3-1b-it",
          "containerSpec": {
            "imageUri": "us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250312_0916_RC01",
            "args": [
              "python",
              "-m",
              "vllm.entrypoints.api_server",
              "--host=0.0.0.0",
              "--port=8080",
              "--model=gs://vertex-model-garden-restricted-us/gemma3/gemma-3-1b-it",
              "--tensor-parallel-size=1",
              "--swap-space=16",
              "--gpu-memory-utilization=0.95",
              "--disable-log-stats"
            ],
            "env": [
              {
                "name": "MODEL_ID",
                "value": "google/gemma-3-1b-it"
              },
              {
                "name": "DEPLOY_SOURCE",
                "value": "UI_NATIVE_MODEL"
              }
            ],
            "ports": [
              {
                "containerPort": 8080
              }
            ],
            "predictRoute": "/generate",
            "healthRoute": "/ping"
          },
          "dedicatedResources": {
            "machineSpec": {
              "machineType": "g2-standard-12",
              "acceleratorType": "NVIDIA_L4",
              "acceleratorCount": 1
            }
          },
          "publicArtifactUri": "gs://vertex-model-garden-restricted-us/gemma3/gemma3.tar.gz",
          "deployTaskName": "vLLM 128K context",
          "deployMetadata": {
            "sampleRequest": "{\n    \"instances\": [\n        {\n          \"@requestFormat\": \"chatCompletions\",\n          \"messages\": [\n              {\n                  \"role\": \"user\",\n                  \"content\": \"What is machine learning?\"\n              }\n          ],\n          \"max_tokens\": 100\n        }\n    ]\n}\n"
          }
        },
        ...

Déployer un modèle

Déployez un modèle depuis Model Garden ou depuis Hugging Face. Vous pouvez également personnaliser le déploiement en spécifiant des champs JSON supplémentaires.

Déployez un modèle avec sa configuration par défaut.

Avant d'utiliser les données de requête, effectuez les remplacements suivants :

  • LOCATION : région où le modèle est déployé.
  • PROJECT_ID : ID de votre projet Google Cloud .
  • MODEL_ID : ID du modèle à déployer, que vous pouvez obtenir en listant tous les modèles déployables. L'ID utilise le format suivant : publishers/PUBLISHER_NAME/models/MODEL_NAME@MODEL_VERSION.

Méthode HTTP et URL : 

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION:deploy

Corps JSON de la requête : 

{
  "publisher_model_name": "MODEL_ID",
  "model_config": {
    "accept_eula": "true"
  }
}

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Enregistrez le corps de la requête dans un fichier nommé request.json. Exécutez la commande suivante dans le terminal pour créer ou écraser ce fichier dans le répertoire actuel : 

cat > request.json << 'EOF'
{
  "publisher_model_name": "MODEL_ID",
  "model_config": {
    "accept_eula": "true"
  }
}
EOF

Exécutez ensuite la commande suivante pour envoyer votre requête REST : 

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION:deploy"

PowerShell

Enregistrez le corps de la requête dans un fichier nommé request.json. Exécutez la commande suivante dans le terminal pour créer ou écraser ce fichier dans le répertoire actuel : 

@'
{
  "publisher_model_name": "MODEL_ID",
  "model_config": {
    "accept_eula": "true"
  }
}
'@  | Out-File -FilePath request.json -Encoding utf8

Exécutez ensuite la commande suivante pour envoyer votre requête REST : 

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION:deploy" | Select-Object -Expand Content

Vous recevez une réponse JSON de ce type :

{
  "name": "projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.DeployOperationMetadata",
    "genericMetadata": {
      "createTime": "2025-03-13T21:44:44.538780Z",
      "updateTime": "2025-03-13T21:44:44.538780Z"
    },
    "publisherModel": "publishers/google/models/gemma3@gemma-3-1b-it",
    "destination": "projects/PROJECT_ID/locations/LOCATION",
    "projectNumber": "PROJECT_ID"
  }
}

Déployer un modèle Hugging Face

Avant d'utiliser les données de requête, effectuez les remplacements suivants :

  • LOCATION : région où le modèle est déployé.
  • PROJECT_ID : ID de votre projet Google Cloud .
  • MODEL_ID : ID du modèle Hugging Face à déployer, que vous pouvez obtenir en listant tous les modèles déployables. L'ID utilise le format suivant : PUBLISHER_NAME/MODEL_NAME.
  • ACCESS_TOKEN : si l'accès au modèle est restreint, fournissez un jeton d'accès.

Méthode HTTP et URL : 

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION:deploy

Corps JSON de la requête : 

{
  "hugging_face_model_id": "MODEL_ID",
  "hugging_face_access_token": "ACCESS_TOKEN",
  "model_config": {
    "accept_eula": "true"
  }
}

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Enregistrez le corps de la requête dans un fichier nommé request.json. Exécutez la commande suivante dans le terminal pour créer ou écraser ce fichier dans le répertoire actuel : 

cat > request.json << 'EOF'
{
  "hugging_face_model_id": "MODEL_ID",
  "hugging_face_access_token": "ACCESS_TOKEN",
  "model_config": {
    "accept_eula": "true"
  }
}
EOF

Exécutez ensuite la commande suivante pour envoyer votre requête REST : 

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION:deploy"

PowerShell

Enregistrez le corps de la requête dans un fichier nommé request.json. Exécutez la commande suivante dans le terminal pour créer ou écraser ce fichier dans le répertoire actuel : 

@'
{
  "hugging_face_model_id": "MODEL_ID",
  "hugging_face_access_token": "ACCESS_TOKEN",
  "model_config": {
    "accept_eula": "true"
  }
}
'@  | Out-File -FilePath request.json -Encoding utf8

Exécutez ensuite la commande suivante pour envoyer votre requête REST : 

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION:deploy" | Select-Object -Expand Content

Vous recevez une réponse JSON de ce type :

{
  "name": "projects/PROJECT_ID/locations/us-central1LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.DeployOperationMetadata",
    "genericMetadata": {
      "createTime": "2025-03-13T21:44:44.538780Z",
      "updateTime": "2025-03-13T21:44:44.538780Z"
    },
    "publisherModel": "publishers/PUBLISHER_NAME/model/MODEL_NAME",
    "destination": "projects/PROJECT_ID/locations/LOCATION",
    "projectNumber": "PROJECT_ID"
  }
}

Déployer un modèle avec des personnalisations

Avant d'utiliser les données de requête, effectuez les remplacements suivants :

  • LOCATION : région où le modèle est déployé.
  • PROJECT_ID : ID de votre projet Google Cloud .
  • MODEL_ID : ID du modèle à déployer, que vous pouvez obtenir en listant tous les modèles déployables. L'ID utilise le format suivant : publishers/PUBLISHER_NAME/models/MODEL_NAME@MODEL_VERSION, par exemple google/gemma@gemma-2b ou stabilityai/stable-diffusion-xl-base-1.0.
  • MACHINE_TYPE : définit l'ensemble de ressources à déployer pour votre modèle, par exemple g2-standard-4.
  • ACCELERATOR_TYPE : spécifie les accélérateurs à ajouter à votre déploiement pour améliorer les performances lorsque vous utilisez des charges de travail intensives, telles que NVIDIA_L4.
  • ACCELERATOR_COUNT : nombre d'accélérateurs à utiliser dans votre déploiement.
  • reservation_affinity_type : pour utiliser une réservation Compute Engine existante pour votre déploiement, spécifiez n'importe quelle réservation ou une spécifique. Si vous spécifiez cette valeur, ne spécifiez pas spot.
  • spot : indique si vous devez utiliser des VM Spot pour votre déploiement.
  • IMAGE_URI : emplacement de l'image de conteneur à utiliser, par exemple us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20241016_0916_RC00_maas.
  • CONTAINER_ARGS : arguments à transmettre au conteneur lors du déploiement.
  • CONTAINER_PORT : numéro de port pour votre conteneur.
  • fast_tryout_enabled : lorsque vous testez un modèle, vous pouvez choisir d'utiliser un déploiement plus rapide. Cette option n'est disponible que pour les modèles très utilisés avec certains types de machines. Si cette option est activée, vous ne pouvez pas spécifier de configurations de modèle ou de déploiement.

Méthode HTTP et URL : 

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION:deploy

Corps JSON de la requête : 

{
  "publisher_model_name": "MODEL_ID",
  "deploy_config": {
    "dedicated_resources": {
      "machine_spec": {
        "machine_type": "MACHINE_TYPE",
        "accelerator_type": "ACCELERATOR_TYPE",
        "accelerator_count": ACCELERATOR_COUNT,
        "reservation_affinity": {
          "reservation_affinity_type": "ANY_RESERVATION"
        }
      },
      "spot": "false"
    }
  },
  "model_config": {
    "accept_eula": "true",
    "container_spec": {
      "image_uri": "IMAGE_URI",
      "args": [CONTAINER_ARGS ],
      "ports": [
        {
          "container_port": CONTAINER_PORT
        }
      ]
    }
  },
  "deploy_config": {
    "fast_tryout_enabled": false
  },
}

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Enregistrez le corps de la requête dans un fichier nommé request.json. Exécutez la commande suivante dans le terminal pour créer ou écraser ce fichier dans le répertoire actuel : 

cat > request.json << 'EOF'
{
  "publisher_model_name": "MODEL_ID",
  "deploy_config": {
    "dedicated_resources": {
      "machine_spec": {
        "machine_type": "MACHINE_TYPE",
        "accelerator_type": "ACCELERATOR_TYPE",
        "accelerator_count": ACCELERATOR_COUNT,
        "reservation_affinity": {
          "reservation_affinity_type": "ANY_RESERVATION"
        }
      },
      "spot": "false"
    }
  },
  "model_config": {
    "accept_eula": "true",
    "container_spec": {
      "image_uri": "IMAGE_URI",
      "args": [CONTAINER_ARGS ],
      "ports": [
        {
          "container_port": CONTAINER_PORT
        }
      ]
    }
  },
  "deploy_config": {
    "fast_tryout_enabled": false
  },
}
EOF

Exécutez ensuite la commande suivante pour envoyer votre requête REST : 

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION:deploy"

PowerShell

Enregistrez le corps de la requête dans un fichier nommé request.json. Exécutez la commande suivante dans le terminal pour créer ou écraser ce fichier dans le répertoire actuel : 

@'
{
  "publisher_model_name": "MODEL_ID",
  "deploy_config": {
    "dedicated_resources": {
      "machine_spec": {
        "machine_type": "MACHINE_TYPE",
        "accelerator_type": "ACCELERATOR_TYPE",
        "accelerator_count": ACCELERATOR_COUNT,
        "reservation_affinity": {
          "reservation_affinity_type": "ANY_RESERVATION"
        }
      },
      "spot": "false"
    }
  },
  "model_config": {
    "accept_eula": "true",
    "container_spec": {
      "image_uri": "IMAGE_URI",
      "args": [CONTAINER_ARGS ],
      "ports": [
        {
          "container_port": CONTAINER_PORT
        }
      ]
    }
  },
  "deploy_config": {
    "fast_tryout_enabled": false
  },
}
'@  | Out-File -FilePath request.json -Encoding utf8

Exécutez ensuite la commande suivante pour envoyer votre requête REST : 

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION:deploy" | Select-Object -Expand Content

Vous recevez une réponse JSON de ce type :

{
  "name": "projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.DeployOperationMetadata",
    "genericMetadata": {
      "createTime": "2025-03-13T21:44:44.538780Z",
      "updateTime": "2025-03-13T21:44:44.538780Z"
    },
    "publisherModel": "publishers/google/models/gemma3@gemma-3-1b-it",
    "destination": "projects/PROJECT_ID/locations/LOCATION",
    "projectNumber": "PROJECT_ID"
  }
}

Console

  1. Dans la console Google Cloud , accédez à la page Model Garden.

    Accéder à Model Garden

  2. Recherchez un modèle compatible que vous souhaitez déployer, puis cliquez sur sa fiche.

  3. Cliquez sur Déployer pour ouvrir le volet Déployer le modèle.

  4. Dans le volet Déployer le modèle, spécifiez les détails de votre déploiement.

    1. Utilisez ou modifiez le nom du modèle et celui du point de terminaison générés.
    2. Sélectionnez un emplacement pour créer le point de terminaison de votre modèle.
    3. Sélectionnez un type de machine à utiliser pour chaque nœud de votre déploiement.

    4. Pour utiliser une réservation Compute Engine, sélectionnez Avancé dans la section Paramètres de déploiement.

      Dans le champ Type de réservation, sélectionnez un type de réservation. La réservation doit correspondre aux spécifications de votre machine.

      • Utiliser automatiquement la réservation créée : Vertex AI sélectionne automatiquement une réservation autorisée avec des propriétés correspondantes. Si la réservation sélectionnée automatiquement ne dispose d'aucune capacité, Vertex AI utilise le pool de ressources Google Cloudgénéral.
      • Sélectionner des réservations spécifiques : Vertex AI utilise une réservation spécifique. Si la capacité de votre réservation sélectionnée est insuffisante, une erreur est générée.
      • Ne pas utiliser (par défaut) : Vertex AI utilise le pool de ressourcesGoogle Cloud général. Cette valeur a le même effet que si vous ne spécifiez pas de réservation.

  5. Cliquez sur Déployer.

Terraform

Pour savoir comment appliquer ou supprimer une configuration Terraform, consultez Commandes Terraform de base. Pour en savoir plus, lisez la documentation de référence du fournisseur Terraform.

Déployer un modèle

L'exemple suivant déploie le modèle gemma-3-1b-it sur un nouveau point de terminaison Vertex AI dans us-central1 à l'aide des configurations par défaut.

terraform {
  required_providers {
    google = {
      source = "hashicorp/google"
      version = "6.45.0"
    }
  }
}

provider "google" {
  region  = "us-central1"
}

resource "google_vertex_ai_endpoint_with_model_garden_deployment" "gemma_deployment" {
  publisher_model_name = "publishers/google/models/gemma3@gemma-3-1b-it"
  location = "us-central1"
  model_config {
    accept_eula = True
  }
}

Pour déployer un modèle avec personnalisation, consultez Point de terminaison Vertex AI avec déploiement Model Garden pour en savoir plus.

Appliquer la configuration

terraform init
terraform plan
terraform apply

Une fois la configuration appliquée, Terraform provisionne un nouveau point de terminaison Vertex AI et déploie le modèle ouvert spécifié.

Effectuer un nettoyage

Pour supprimer le point de terminaison et le déploiement du modèle, exécutez la commande suivante :

terraform destroy

Effectuer une inférence du modèle Gemma 1B avec PredictionServiceClient

Après avoir déployé Gemma 1B, vous pouvez utiliser PredictionServiceClient pour obtenir des prédictions en ligne pour le prompt "Pourquoi le ciel est-il bleu ?"

Paramètres de code

Les exemples de code PredictionServiceClient nécessitent que vous mettiez à jour les éléments suivants.

  • PROJECT_ID : pour trouver l'ID de votre projet, procédez comme suit.

    1. Accédez à la page d'accueil de la console Google Cloud .

      Accéder à la page d'accueil

    2. Dans le sélecteur de projets situé en haut de la page, sélectionnez votre projet.

      Le nom ainsi que le numéro et l'ID du projet apparaissent après l'en-tête Bienvenue.

  • ENDPOINT_REGION : région dans laquelle vous avez déployé le point de terminaison.

  • ENDPOINT_ID : pour trouver l'ID de votre point de terminaison, affichez-le dans la console ou exécutez la commande gcloud ai endpoints list. Vous aurez besoin du nom et de la région du point de terminaison dans le volet Déployer le modèle.

    Console

    Vous pouvez afficher les détails du point de terminaison en cliquant sur Prédiction en ligne > Points de terminaison et en sélectionnant votre région. Notez le nombre qui s'affiche dans la colonne ID.

    Accéder à la page "Points de terminaison"

    gcloud

    Vous pouvez afficher les détails du point de terminaison en exécutant la commande gcloud ai endpoints list.

    gcloud ai endpoints list \
  --region=ENDPOINT_REGION \
  --filter=display_name=ENDPOINT_NAME

    Le résultat ressemble à ceci :

    Using endpoint [https://us-central1-aiplatform.googleapis.com/]
ENDPOINT_ID: 1234567891234567891
DISPLAY_NAME: gemma2-2b-it-mg-one-click-deploy

Exemple de code

Dans l'exemple de code correspondant à votre langage, modifiez PROJECT_ID, ENDPOINT_REGION et ENDPOINT_ID. Exécutez ensuite votre code.

Python

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'API Python. 

"""
Sample to run inference on a Gemma2 model deployed to a Vertex AI endpoint with GPU accellerators.
"""

from google.cloud import aiplatform
from google.protobuf import json_format
from google.protobuf.struct_pb2 import Value

# TODO(developer): Update & uncomment lines below
# PROJECT_ID = "your-project-id"
# ENDPOINT_REGION = "your-vertex-endpoint-region"
# ENDPOINT_ID = "your-vertex-endpoint-id"

# Default configuration
config = {"max_tokens": 1024, "temperature": 0.9, "top_p": 1.0, "top_k": 1}

# Prompt used in the prediction
prompt = "Why is the sky blue?"

# Encapsulate the prompt in a correct format for GPUs
# Example format: [{'inputs': 'Why is the sky blue?', 'parameters': {'temperature': 0.9}}]
input = {"inputs": prompt, "parameters": config}

# Convert input message to a list of GAPIC instances for model input
instances = [json_format.ParseDict(input, Value())]

# Create a client
api_endpoint = f"{ENDPOINT_REGION}-aiplatform.googleapis.com"
client = aiplatform.gapic.PredictionServiceClient(
    client_options={"api_endpoint": api_endpoint}
)

# Call the Gemma2 endpoint
gemma2_end_point = (
    f"projects/{PROJECT_ID}/locations/{ENDPOINT_REGION}/endpoints/{ENDPOINT_ID}"
)
response = client.predict(
    endpoint=gemma2_end_point,
    instances=instances,
)
text_responses = response.predictions
print(text_responses[0])

Node.js

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js décrites dans le guide de démarrage rapide de Vertex AI sur l'utilisation des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI pour Node.js.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

async function gemma2PredictGpu(predictionServiceClient) {
  // Imports the Google Cloud Prediction Service Client library
  const {
    // TODO(developer): Uncomment PredictionServiceClient before running the sample.
    // PredictionServiceClient,
    helpers,
  } = require('@google-cloud/aiplatform');
  /**
   * TODO(developer): Update these variables before running the sample.
   */
  const projectId = 'your-project-id';
  const endpointRegion = 'your-vertex-endpoint-region';
  const endpointId = 'your-vertex-endpoint-id';

  // Default configuration
  const config = {maxOutputTokens: 1024, temperature: 0.9, topP: 1.0, topK: 1};
  // Prompt used in the prediction
  const prompt = 'Why is the sky blue?';

  // Encapsulate the prompt in a correct format for GPUs
  // Example format: [{inputs: 'Why is the sky blue?', parameters: {temperature: 0.9}}]
  const input = {
    inputs: prompt,
    parameters: config,
  };

  // Convert input message to a list of GAPIC instances for model input
  const instances = [helpers.toValue(input)];

  // TODO(developer): Uncomment apiEndpoint and predictionServiceClient before running the sample.
  // const apiEndpoint = `${endpointRegion}-aiplatform.googleapis.com`;

  // Create a client
  // predictionServiceClient = new PredictionServiceClient({apiEndpoint});

  // Call the Gemma2 endpoint
  const gemma2Endpoint = `projects/${projectId}/locations/${endpointRegion}/endpoints/${endpointId}`;

  const [response] = await predictionServiceClient.predict({
    endpoint: gemma2Endpoint,
    instances,
  });

  const predictions = response.predictions;
  const text = predictions[0].stringValue;

  console.log('Predictions:', text);
  return text;
}

module.exports = gemma2PredictGpu;

// TODO(developer): Uncomment below lines before running the sample.
// gemma2PredictGpu(...process.argv.slice(2)).catch(err => {
//   console.error(err.message);
//   process.exitCode = 1;
// });

Java

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java décrites dans le guide de démarrage rapide de Vertex AI sur l'utilisation des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI pour Java.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 


import com.google.cloud.aiplatform.v1.EndpointName;
import com.google.cloud.aiplatform.v1.PredictResponse;
import com.google.cloud.aiplatform.v1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1.PredictionServiceSettings;
import com.google.gson.Gson;
import com.google.protobuf.InvalidProtocolBufferException;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Gemma2PredictGpu {

  private final PredictionServiceClient predictionServiceClient;

  // Constructor to inject the PredictionServiceClient
  public Gemma2PredictGpu(PredictionServiceClient predictionServiceClient) {
    this.predictionServiceClient = predictionServiceClient;
  }

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String endpointRegion = "us-east4";
    String endpointId = "YOUR_ENDPOINT_ID";

    PredictionServiceSettings predictionServiceSettings =
        PredictionServiceSettings.newBuilder()
            .setEndpoint(String.format("%s-aiplatform.googleapis.com:443", endpointRegion))
            .build();
    PredictionServiceClient predictionServiceClient =
        PredictionServiceClient.create(predictionServiceSettings);
    Gemma2PredictGpu creator = new Gemma2PredictGpu(predictionServiceClient);

    creator.gemma2PredictGpu(projectId, endpointRegion, endpointId);
  }

  // Demonstrates how to run inference on a Gemma2 model
  // deployed to a Vertex AI endpoint with GPU accelerators.
  public String gemma2PredictGpu(String projectId, String region,
               String endpointId) throws IOException {
    Map<String, Object> paramsMap = new HashMap<>();
    paramsMap.put("temperature", 0.9);
    paramsMap.put("maxOutputTokens", 1024);
    paramsMap.put("topP", 1.0);
    paramsMap.put("topK", 1);
    Value parameters = mapToValue(paramsMap);

    // Prompt used in the prediction
    String instance = "{ \"inputs\": \"Why is the sky blue?\"}";
    Value.Builder instanceValue = Value.newBuilder();
    JsonFormat.parser().merge(instance, instanceValue);
    // Encapsulate the prompt in a correct format for GPUs
    // Example format: [{'inputs': 'Why is the sky blue?', 'parameters': {'temperature': 0.8}}]
    List<Value> instances = new ArrayList<>();
    instances.add(instanceValue.build());

    EndpointName endpointName = EndpointName.of(projectId, region, endpointId);

    PredictResponse predictResponse = this.predictionServiceClient
        .predict(endpointName, instances, parameters);
    String textResponse = predictResponse.getPredictions(0).getStringValue();
    System.out.println(textResponse);
    return textResponse;
  }

  private static Value mapToValue(Map<String, Object> map) throws InvalidProtocolBufferException {
    Gson gson = new Gson();
    String json = gson.toJson(map);
    Value.Builder builder = Value.newBuilder();
    JsonFormat.parser().merge(json, builder);
    return builder.build();
  }
}

Go

Avant d'essayer cet exemple, suivez les instructions de configuration pour Go décrites dans le guide de démarrage rapide de Vertex AI sur l'utilisation des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI pour Go.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/aiplatform/apiv1/aiplatformpb"

	"google.golang.org/protobuf/types/known/structpb"
)

// predictGPU demonstrates how to run interference on a Gemma2 model deployed to a Vertex AI endpoint with GPU accelerators.
func predictGPU(w io.Writer, client PredictionsClient, projectID, location, endpointID string) error {
	ctx := context.Background()

	// Note: client can be initialized in the following way:
	// apiEndpoint := fmt.Sprintf("%s-aiplatform.googleapis.com:443", location)
	// client, err := aiplatform.NewPredictionClient(ctx, option.WithEndpoint(apiEndpoint))
	// if err != nil {
	// 	return fmt.Errorf("unable to create prediction client: %v", err)
	// }
	// defer client.Close()

	gemma2Endpoint := fmt.Sprintf("projects/%s/locations/%s/endpoints/%s", projectID, location, endpointID)
	prompt := "Why is the sky blue?"
	parameters := map[string]interface{}{
		"temperature":     0.9,
		"maxOutputTokens": 1024,
		"topP":            1.0,
		"topK":            1,
	}

	// Encapsulate the prompt in a correct format for TPUs.
	// Pay attention that prompt should be set in "inputs" field.
	// Example format: [{'inputs': 'Why is the sky blue?', 'parameters': {'temperature': 0.9}}]
	promptValue, err := structpb.NewValue(map[string]interface{}{
		"inputs":     prompt,
		"parameters": parameters,
	})
	if err != nil {
		fmt.Fprintf(w, "unable to convert prompt to Value: %v", err)
		return err
	}

	req := &aiplatformpb.PredictRequest{
		Endpoint:  gemma2Endpoint,
		Instances: []*structpb.Value{promptValue},
	}

	resp, err := client.Predict(ctx, req)
	if err != nil {
		return err
	}

	prediction := resp.GetPredictions()
	value := prediction[0].GetStringValue()
	fmt.Fprintf(w, "%v", value)

	return nil
}