Desplegar y usar Gemma para inferencias con Model Garden y endpoints con GPU de Vertex AI

En este tutorial, usarás Model Garden para desplegar el modelo abierto Gemma 1B en un endpoint de Vertex AI con GPU. Debes desplegar un modelo en un endpoint para poder usarlo y ofrecer predicciones online. Al desplegar un modelo, se asocian recursos físicos a este para que pueda ofrecer predicciones online con baja latencia.

Una vez que hayas desplegado el modelo Gemma 1B, podrás inferir el modelo entrenado mediante PredictionServiceClient para obtener predicciones online. Las predicciones online son solicitudes síncronas que se envían a un modelo desplegado en un endpoint.

Objetivos

En este tutorial se explica cómo realizar las siguientes tareas:

  • Desplegar el modelo abierto Gemma 1B en un endpoint con GPU mediante Model Garden
  • Usar PredictionServiceClient para obtener predicciones online

Costes

En este documento, se utilizan los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costes basada en el uso previsto, utiliza la calculadora de precios.

Los usuarios nuevos Google Cloud pueden disfrutar de una prueba gratuita.

Cuando termines las tareas que se describen en este documento, puedes evitar que se te siga facturando eliminando los recursos que has creado. Para obtener más información, consulta la sección Limpiar.

Antes de empezar

Para hacer este tutorial, debes:

  • Configurar un Google Cloud proyecto y habilitar la API de Vertex AI
  • En tu equipo local:
    • Instalar, inicializar y autenticar con la CLI de Google Cloud
    • Instalar el SDK de tu idioma

Configurar un Google Cloud proyecto

Configura tu Google Cloud proyecto y habilita la API Vertex AI.

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. Enable the Vertex AI API.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the API

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  6. Verify that billing is enabled for your Google Cloud project.

  7. Enable the Vertex AI API.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the API

    8.

    Configurar Google Cloud CLI

    En tu máquina local, configura Google Cloud CLI.

    1. Instala e inicializa la CLI de Google Cloud.

    2. Si ya has instalado la CLI de gcloud, asegúrate de que tus componentes de gcloud estén actualizados ejecutando este comando.

      gcloud components update

    3. Para autenticarte con la CLI de gcloud, genera un archivo local de credenciales predeterminadas de la aplicación (ADC) ejecutando este comando. El flujo web que inicia el comando se usa para proporcionar las credenciales de usuario.

      gcloud auth application-default login

      Para obtener más información, consulta Configuración de autenticación de la CLI de gcloud y configuración de ADC.

    Configurar el SDK para tu lenguaje de programación

    Para configurar el entorno que se usa en este tutorial, instala el SDK de Vertex AI para tu idioma y la biblioteca Protocol Buffers. Los ejemplos de código usan funciones de la biblioteca Protocol Buffers para convertir el diccionario de entrada al formato JSON que espera la API.

    En tu máquina local, haz clic en una de las siguientes pestañas para instalar el SDK de tu lenguaje de programación.

    Python

    En tu máquina local, haz clic en una de las siguientes pestañas para instalar el SDK de tu lenguaje de programación.

    • Instala y actualiza el SDK de Vertex AI para Python ejecutando este comando.

      pip3 install --upgrade "google-cloud-aiplatform>=1.64"

    • Instala la biblioteca Protocol Buffers para Python ejecutando este comando.

      pip3 install --upgrade "protobuf>=5.28"

    Node.js

    Instala o actualiza el SDK de aiplatform para Node.js ejecutando el siguiente comando.

    npm install @google-cloud/aiplatform

    Java

    Para añadir google-cloud-aiplatform como dependencia, añade el código adecuado para tu entorno.

    Maven con BOM

    Añade el siguiente código HTML a tu pom.xml:

    <dependencyManagement>
<dependencies>
  <dependency>
    <artifactId>libraries-bom</artifactId>
    <groupId>com.google.cloud</groupId>
    <scope>import</scope>
    <type>pom</type>
    <version>26.34.0</version>
  </dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<dependency>
  <groupId>com.google.cloud</groupId>
  <artifactId>google-cloud-aiplatform</artifactId>
</dependency>
<dependency>
  <groupId>com.google.protobuf</groupId>
  <artifactId>protobuf-java-util</artifactId>
</dependency>
<dependency>
  <groupId>com.google.code.gson</groupId>
  <artifactId>gson</artifactId>
</dependency>
</dependencies>

    Maven sin BOM

    Añade lo siguiente a tu pom.xml:

    <dependency>
  <groupId>com.google.cloud</groupId>
  <artifactId>google-cloud-aiplatform</artifactId>
  <version>1.1.0</version>
</dependency>
<dependency>
  <groupId>com.google.protobuf</groupId>
  <artifactId>protobuf-java-util</artifactId>
  <version>5.28</version>
</dependency>
<dependency>
  <groupId>com.google.code.gson</groupId>
  <artifactId>gson</artifactId>
  <version>2.11.0</version>
</dependency>

    Gradle sin BOM

    Añade lo siguiente a tu build.gradle:

    implementation 'com.google.cloud:google-cloud-aiplatform:1.1.0'

    Go

    Instala estos paquetes de Go ejecutando los siguientes comandos.

    go get cloud.google.com/go/aiplatform
go get google.golang.org/protobuf
go get github.com/googleapis/gax-go/v2

    Desplegar Gemma con Model Garden

    Puedes implementar Gemma 1B mediante su tarjeta de modelo en la Google Cloud consola o de forma programática.

    Para obtener más información sobre cómo configurar el SDK de IA generativa de Google o la CLI de Google Cloud, consulta la descripción general del SDK de IA generativa de Google o el artículo sobre cómo instalar la CLI de Google Cloud.

    Python

    Para saber cómo instalar o actualizar el SDK de Vertex AI para Python, consulta Instalar el SDK de Vertex AI para Python. Para obtener más información, consulta la documentación de referencia de la API Python.

    1. Lista los modelos que puedes desplegar y registra el ID del modelo que quieres desplegar. También puedes consultar los modelos de Hugging Face admitidos en Model Garden e incluso filtrarlos por nombre. El resultado no incluye ningún modelo ajustado.

      
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. Consulta las especificaciones de la implementación de un modelo mediante el ID del modelo del paso anterior. Puedes ver el tipo de máquina, el tipo de acelerador y el URI de la imagen de contenedor que Model Garden ha verificado para un modelo concreto.

      
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. Despliega un modelo en un endpoint. Model Garden usa la configuración de implementación predeterminada, a menos que especifiques argumentos y valores adicionales.

      
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

    Antes de empezar, especifica un proyecto de cuota para ejecutar los siguientes comandos. Los comandos que ejecutes se contabilizarán en las cuotas de ese proyecto. Para obtener más información, consulta Definir el proyecto de cuota.

    1. Para ver los modelos que puedes implementar, ejecuta el comando gcloud ai model-garden models list. Este comando muestra todos los IDs de modelo y cuáles puedes implementar por tu cuenta.

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

      En el resultado, busca el ID del modelo que quieras implementar. En el siguiente ejemplo se muestra una salida abreviada.

      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 salida no incluye ningún modelo optimizado ni ningún modelo de Hugging Face. Para ver qué modelos de Hugging Face se admiten, añade la marca --can-deploy-hugging-face-models.

    2. Para ver las especificaciones de implementación de un modelo, ejecuta el comando gcloud ai model-garden models list-deployment-config. Puedes ver el tipo de máquina, el tipo de acelerador y el URI de la imagen del contenedor que admite Model Garden para un modelo concreto.

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

      Sustituye MODEL_ID por el ID del modelo de la lista anterior comando, como google/gemma@gemma-2b o stabilityai/stable-diffusion-xl-base-1.0.

    3. Despliega un modelo en un endpoint ejecutando el comando gcloud ai model-garden models deploy. Model Garden genera un nombre visible para tu endpoint y usa la configuración de implementación predeterminada, a menos que especifiques argumentos y valores adicionales.

      Para ejecutar el comando de forma asíncrona, incluye la marca --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]

      Sustituye los siguientes marcadores de posición:

      • MODEL_ID: el ID del modelo del comando de lista anterior. En el caso de los modelos de Hugging Face, utiliza el formato de URL de modelo de Hugging Face, como stabilityai/stable-diffusion-xl-base-1.0.
      • MACHINE_TYPE: define el conjunto de recursos que se van a implementar para tu modelo, como g2-standard-4.
      • ACCELERATOR_TYPE: especifica los aceleradores que se van a añadir a tu implementación para mejorar el rendimiento al trabajar con cargas de trabajo intensivas, como NVIDIA_L4.
      • ENDPOINT_NAME: nombre del endpoint de Vertex AI implementado.
      • HF_ACCESS_TOKEN: en el caso de los modelos de Hugging Face, si el modelo está protegido, proporciona un token de acceso.
      • RESERVATION_RESOURCE_NAME: para usar una reserva de Compute Engine específica, indica el nombre de la reserva. Si especifica una reserva concreta, no puede especificar any-reservation.

      El resultado incluye la configuración del despliegue que ha usado Model Garden, el ID del endpoint y el ID de la operación de despliegue, que puedes usar para comprobar el estado del despliegue.

      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. Para ver los detalles de tu implementación, ejecuta el comando gcloud ai endpoints list --list-model-garden-endpoints-only:

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

      Sustituye LOCATION_ID por la región en la que has desplegado el modelo.

      El resultado incluye todos los endpoints que se han creado en Model Garden, así como información como el ID y el nombre del endpoint, y si está asociado a un modelo implementado. Para encontrar tu implementación, busca el nombre del endpoint que se ha devuelto en el comando anterior.

    REST

    Muestra todos los modelos que se pueden desplegar y, a continuación, obtiene el ID del modelo que quieres desplegar. Después, puede desplegar el modelo con su configuración y endpoint predeterminados. También puedes personalizar tu implementación, como definir un tipo de máquina específico o usar un endpoint dedicado.

    Mostrar los modelos que puedes desplegar

    Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

    • PROJECT_ID: tu ID de proyecto Google Cloud .
    • QUERY_PARAMETERS: para enumerar los modelos de Model Garden, añade los siguientes parámetros de consulta: listAllVersions=True&filter=is_deployable(true). Para enumerar los modelos de Hugging Face, define el filtro como alt=json&is_hf_wildcard(true)+AND+labels.VERIFIED_DEPLOYMENT_CONFIG%3DVERIFIED_DEPLOYMENT_SUCCEED&listAllVersions=True.

    Método HTTP y URL: 

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

    Para enviar tu solicitud, elige una de estas opciones:

    curl

    Ejecuta el comando siguiente: 

    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

    Ejecuta el comando siguiente: 

    $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

    Recibirás una respuesta JSON similar a la siguiente.

    {
  "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"
          }
        },
        ...

    Desplegar un modelo

    Despliega un modelo de Model Garden o un modelo de Hugging Face. También puedes personalizar la implementación especificando campos JSON adicionales.

    Despliega un modelo con su configuración predeterminada.

    Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

    • LOCATION: región en la que se ha desplegado el modelo.
    • PROJECT_ID: tu ID de proyecto Google Cloud .
    • MODEL_ID: ID del modelo que se va a implementar. Puedes obtenerlo consultando todos los modelos que se pueden implementar. El ID usa el siguiente formato: publishers/PUBLISHER_NAME/models/ MODEL_NAME@MODEL_VERSION.

    Método HTTP y URL: 

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

    Cuerpo JSON de la solicitud: 

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

    Para enviar tu solicitud, elige una de estas opciones:

    curl

    Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el siguiente comando en el terminal para crear o sobrescribir este archivo en el directorio actual: 

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

    A continuación, ejecuta el siguiente comando para enviar tu solicitud 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

    Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el siguiente comando en el terminal para crear o sobrescribir este archivo en el directorio actual: 

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

    A continuación, ejecuta el siguiente comando para enviar tu solicitud 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

    Recibirás una respuesta JSON similar a la siguiente.

    {
  "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"
  }
}

    Desplegar un modelo de Hugging Face

    Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

    • LOCATION: región en la que se ha desplegado el modelo.
    • PROJECT_ID: tu ID de proyecto Google Cloud .
    • MODEL_ID: el modelo de Hugging Face ID del modelo que se va a implementar. Puedes obtenerlo consultando todos los modelos que se pueden implementar. El ID tiene el siguiente formato: PUBLISHER_NAME/MODEL_NAME.
    • ACCESS_TOKEN: si el modelo está protegido, proporciona un token de acceso.

    Método HTTP y URL: 

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

    Cuerpo JSON de la solicitud: 

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

    Para enviar tu solicitud, elige una de estas opciones:

    curl

    Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el siguiente comando en el terminal para crear o sobrescribir este archivo en el directorio actual: 

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

    A continuación, ejecuta el siguiente comando para enviar tu solicitud 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

    Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el siguiente comando en el terminal para crear o sobrescribir este archivo en el directorio actual: 

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

    A continuación, ejecuta el siguiente comando para enviar tu solicitud 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

    Recibirás una respuesta JSON similar a la siguiente.

    {
  "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"
  }
}

    Desplegar un modelo con personalizaciones

    Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

    • LOCATION: región en la que se ha desplegado el modelo.
    • PROJECT_ID: tu ID de proyecto Google Cloud .
    • MODEL_ID: ID del modelo que se va a implementar. Puedes obtenerlo consultando todos los modelos que se pueden implementar. El ID usa el siguiente formato: publishers/PUBLISHER_NAME/models/ MODEL_NAME@MODEL_VERSION, como google/gemma@gemma-2b o stabilityai/stable-diffusion-xl-base-1.0.
    • MACHINE_TYPE: define el conjunto de recursos que se van a implementar para tu modelo, como g2-standard-4.
    • ACCELERATOR_TYPE: Especifica los aceleradores que se deben añadir a tu implementación para mejorar el rendimiento cuando trabajes con cargas de trabajo intensivas, como NVIDIA_L4.
    • ACCELERATOR_COUNT: número de aceleradores que se van a usar en la implementación.
    • reservation_affinity_type: Para usar una reserva de Compute Engine que ya tengas en tu despliegue, especifica cualquier reserva o una concreta. Si especifica este valor, no especifique spot.
    • spot: indica si se deben usar VMs de acceso puntual para el despliegue.
    • IMAGE_URI: la ubicación de la imagen del contenedor que se va a usar, como us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20241016_0916_RC00_maas
    • CONTAINER_ARGS: argumentos que se transfieren al contenedor durante la implementación.
    • CONTAINER_PORT: número de puerto de tu contenedor.
    • fast_tryout_enabled: Cuando pruebes un modelo, puedes elegir entre usar un despliegue más rápido. Esta opción solo está disponible para los modelos más usados con determinados tipos de máquinas. Si está habilitada, no puede especificar configuraciones de modelo ni de implementación.

    Método HTTP y URL: 

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

    Cuerpo JSON de la solicitud: 

    {
  "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
  },
}

    Para enviar tu solicitud, elige una de estas opciones:

    curl

    Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el siguiente comando en el terminal para crear o sobrescribir este archivo en el directorio actual: 

    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

    A continuación, ejecuta el siguiente comando para enviar tu solicitud 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

    Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el siguiente comando en el terminal para crear o sobrescribir este archivo en el directorio actual: 

    @'
{
  "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

    A continuación, ejecuta el siguiente comando para enviar tu solicitud 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

    Recibirás una respuesta JSON similar a la siguiente.

    {
  "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"
  }
}

    Consola

    1. En la Google Cloud consola, ve a la página Model Garden.

      Ir a Model Garden

    2. Busca el modelo admitido que quieras implementar y haz clic en su tarjeta de modelo.

    3. Haga clic en Implementar para abrir el panel Implementar modelo.

    4. En el panel Implementar modelo, especifica los detalles de la implementación.

      1. Usa o modifica los nombres del modelo y del endpoint generados.
      2. Seleccione una ubicación para crear el endpoint del modelo.
      3. Selecciona un tipo de máquina para cada nodo de tu implementación.

      4. Para usar una reserva de Compute Engine, en la sección Ajustes de implementación, selecciona Avanzado.

        En el campo Tipo de reserva, seleccione un tipo de reserva. La reserva debe coincidir con las especificaciones de la máquina que hayas indicado.

        • Utilizar de forma automática la reserva creada: Vertex AI selecciona automáticamente una reserva permitida con propiedades coincidentes. Si no hay capacidad en la reserva seleccionada automáticamente, Vertex AI usa el grupo de recursos general Google Cloud.
        • Seleccionar reservas específicas: Vertex AI usa una reserva específica. Si no hay capacidad para la reserva seleccionada, se producirá un error.
        • No usar (opción predeterminada): Vertex AI usa el grupo de recursosGoogle Cloud general. Este valor tiene el mismo efecto que no especificar una reserva.

    5. Haz clic en Desplegar.

    Terraform

    Para saber cómo aplicar o quitar una configuración de Terraform, consulta Comandos básicos de Terraform. Para obtener más información, consulta la documentación de referencia del proveedor Terraform.

    Desplegar un modelo

    En el siguiente ejemplo, se despliega el modelo gemma-3-1b-it en un nuevo endpoint de Vertex AI en us-central1 con las configuraciones predeterminadas.

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

    Para desplegar un modelo con personalización, consulta Endpoint de Vertex AI con despliegue de Model Garden.

    Aplicar la configuración

    terraform init
terraform plan
terraform apply

    Después de aplicar la configuración, Terraform aprovisiona un nuevo endpoint de Vertex AI y despliega el modelo abierto especificado.

    Limpieza

    Para eliminar el endpoint y el despliegue del modelo, ejecuta el siguiente comando:

    terraform destroy

    Inferir Gemma 1B con PredictionServiceClient

    Después de desplegar Gemma 1B, usas la PredictionServiceClient para obtener predicciones online de la petición "¿Por qué el cielo es azul?".

    Parámetros de código

    En los ejemplos de código de PredictionServiceClient, debes actualizar lo siguiente.

    • PROJECT_ID: Para encontrar el ID de tu proyecto, sigue estos pasos.

      1. Ve a la página Bienvenida de la Google Cloud consola.

        Ir a Bienvenida

      2. En el selector de proyectos de la parte superior de la página, selecciona tu proyecto.

        El nombre, el número y el ID del proyecto aparecen después del encabezado Bienvenido.

    • ENDPOINT_REGION: es la región en la que has implementado el endpoint.

    • ENDPOINT_ID: Para encontrar tu ID de endpoint, consúltalo en la consola o ejecuta el comando gcloud ai endpoints list. Necesitarás el nombre y la región del endpoint del panel Implementar modelo.

      Consola

      Para ver los detalles del endpoint, haga clic en Predicción online > Endpoints y seleccione su región. Fíjate en el número que aparece en la columna ID.

      Ir a Endpoints

      gcloud

      Para ver los detalles del endpoint, ejecuta el comando gcloud ai endpoints list.

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

      La salida tiene este aspecto.

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

    Código de muestra

    En el código de ejemplo de tu idioma, actualiza PROJECT_ID, ENDPOINT_REGION y ENDPOINT_ID. A continuación, ejecuta el código.

    Python

    Para saber cómo instalar o actualizar el SDK de Vertex AI para Python, consulta Instalar el SDK de Vertex AI para Python. Para obtener más información, consulta la documentación de referencia de la 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

    Antes de probar este ejemplo, sigue las Node.js instrucciones de configuración de la guía de inicio rápido de Vertex AI con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js de Vertex AI.

    Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo 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

    Antes de probar este ejemplo, sigue las Java instrucciones de configuración de la guía de inicio rápido de Vertex AI con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Java de Vertex AI.

    Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo 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

    Antes de probar este ejemplo, sigue las Go instrucciones de configuración de la guía de inicio rápido de Vertex AI con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Go de Vertex AI.

    Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo 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
}

    Limpieza

    Para evitar que los recursos utilizados en este tutorial se cobren en tu cuenta de Google Cloud, elimina el proyecto que contiene los recursos o conserva el proyecto y elimina los recursos.

    Eliminar el proyecto

    1. In the Google Cloud console, go to the Manage resources page.

      Go to Manage resources

    2. In the project list, select the project that you want to delete, and then click Delete.
    3. In the dialog, type the project ID, and then click Shut down to delete the project.

    Eliminar recursos concretos

    Si vas a conservar el proyecto, elimina los recursos que has usado en este tutorial:

    • Anular el despliegue del modelo y eliminar el endpoint
    • Eliminar el modelo del registro de modelos

    Anular el despliegue del modelo y eliminar el endpoint

    Utilice uno de los siguientes métodos para retirar un modelo y eliminar el endpoint.

    Consola

    1. En la Google Cloud consola, haz clic en Predicción online y, a continuación, en Endpoints.

      Ir a la página Endpoints

    2. En la lista desplegable Región, elige la región en la que has implementado tu endpoint.

    3. Haz clic en el nombre del endpoint para abrir la página de detalles. Por ejemplo: gemma2-2b-it-mg-one-click-deploy.

    4. En la fila del modelo Gemma 2 (Version 1), haga clic en Acciones y, a continuación, en Retirar modelo del endpoint.

    5. En el cuadro de diálogo Anular despliegue de modelo de punto final, haz clic en Anular despliegue.

    6. Haz clic en el botón Atrás para volver a la página Endpoints (Endpoints)

      Ir a la página Endpoints

    7. Al final de la fila gemma2-2b-it-mg-one-click-deploy, haga clic en Acciones y, a continuación, seleccione Eliminar endpoint.

    8. En la ventana de confirmación, haz clic en Confirmar.

    gcloud

    Para retirar el modelo y eliminar el endpoint con la CLI de Google Cloud, sigue estos pasos.

    En estos comandos, sustituye lo siguiente:

    • PROJECT_ID con el nombre de tu proyecto
    • LOCATION_ID por la región en la que has desplegado el modelo y el endpoint
    • ENDPOINT_ID con el ID del endpoint
    • DEPLOYED_MODEL_NAME con el nombre visible del modelo
    • DEPLOYED_MODEL_ID con el ID del modelo

    1. Obtén el ID del endpoint ejecutando el comando gcloud ai endpoints list. Este comando muestra los IDs de endpoint de todos los endpoints de tu proyecto. Anota el ID del endpoint que se ha usado en este tutorial.

      gcloud ai endpoints list \
    --project=PROJECT_ID \
    --region=LOCATION_ID

      La salida tiene este aspecto. En el resultado, el ID se llama ENDPOINT_ID.

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

    2. Obtén el ID del modelo ejecutando el comando gcloud ai models describe. Anota el ID del modelo que has implementado en este tutorial.

      gcloud ai models describe DEPLOYED_MODEL_NAME \
    --project=PROJECT_ID \
    --region=LOCATION_ID

      La salida abreviada tiene este aspecto. En el resultado, el ID se llama deployedModelId.

      Using endpoint [https://us-central1-aiplatform.googleapis.com/]
artifactUri: [URI removed]
baseModelSource:
  modelGardenSource:
    publicModelName: publishers/google/models/gemma2
...
deployedModels:
- deployedModelId: '1234567891234567891'
  endpoint: projects/12345678912/locations/us-central1/endpoints/12345678912345
displayName: gemma2-2b-it-12345678912345
etag: [ETag removed]
modelSourceInfo:
  sourceType: MODEL_GARDEN
name: projects/123456789123/locations/us-central1/models/gemma2-2b-it-12345678912345
...

    3. Anula el despliegue del modelo en el endpoint. Necesitarás el ID de endpoint y el ID de modelo de los comandos anteriores.

      gcloud ai endpoints undeploy-model ENDPOINT_ID \
    --project=PROJECT_ID \
    --region=LOCATION_ID \
    --deployed-model-id=DEPLOYED_MODEL_ID

      Este comando no genera ninguna salida.

    4. Ejecuta el comando gcloud ai endpoints delete para eliminar el endpoint.

      gcloud ai endpoints delete ENDPOINT_ID \
    --project=PROJECT_ID \
    --region=LOCATION_ID

      Cuando se te solicite, escribe y para confirmar la acción. Este comando no genera ninguna salida.

    Eliminar el modelo

    Consola

    1. Ve a la página Registro de modelos de la sección Vertex AI de la consola de Google Cloud .

      Ve a la página Registro de modelos.

    2. En la lista desplegable Región, elige la región en la que has implementado el modelo.

    3. Al final de la fila gemma2-2b-it-1234567891234, haz clic en Acciones.

    4. Selecciona Eliminar modelo.

      Cuando eliminas el modelo, todas las versiones y evaluaciones asociadas se eliminan de tu Google Cloud proyecto.

    5. En la ventana de confirmación, haz clic en Eliminar.

    gcloud

    Para eliminar el modelo con Google Cloud CLI, proporciona el nombre visible y la región del modelo al comando gcloud ai models delete.

    gcloud ai models delete DEPLOYED_MODEL_NAME \
    --project=PROJECT_ID \
    --region=LOCATION_ID

    Sustituye DEPLOYED_MODEL_NAME por el nombre visible del modelo. Sustituye PROJECT_ID por el nombre de tu proyecto. Sustituye LOCATION_ID por la región en la que has desplegado el modelo.

    Siguientes pasos