Usar modelos en Model Garden

Descubre, prueba, ajusta y despliega modelos con Model Garden en laGoogle Cloud consola. También puedes desplegar modelos de Model Garden con la CLI de Google Cloud.

Enviar peticiones de prueba

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

    Ir a Model Garden

  2. Busca un modelo compatible que quieras probar y haz clic en Ver detalles.

  3. Haz clic en Abrir diseño de petición.

    Accederás a la página Diseño de peticiones.

  4. En Petición, introduce la petición que quieras probar.

  5. Opcional: Configura los parámetros del modelo.

  6. Haz clic en Enviar.

Ajustar un modelo

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

    Ir a Model Garden

  2. En Buscar modelos, introduce BERT o T5-FLAN y, a continuación, haz clic en la lupa para buscar.

  3. Haz clic en Ver detalles en la tarjeta del modelo T5-FLAN o BERT.

  4. Haz clic en Abrir la canalización de ajuste fino.

    Se te dirigirá a la página de flujos de procesamiento de Vertex AI.

  5. Para empezar a ajustar los parámetros, haz clic en Crear ejecución.

Sintonizar un cuaderno

Las tarjetas de modelo de la mayoría de los modelos básicos de código abierto y los modelos que se pueden ajustar admiten el ajuste en un cuaderno.

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

    Ir a Model Garden

  2. Busca un modelo compatible que quieras ajustar y ve a su tarjeta de modelo.

  3. Haz clic en Abrir cuaderno.

Desplegar un modelo abierto

Puedes desplegar un modelo 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 optimizado.

    
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. Para ver las especificaciones de la implementación de un modelo, usa 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

    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 de la implementación que ha usado Model Garden, el ID del endpoint y el ID de la operación de implementación, que puedes usar para comprobar el estado de la implementación.

    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.

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

2. Desplegar un modelo

Despliega un modelo de Model Garden o 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 pool 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 produce 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 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 para obtener más información.

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

Desplegar un modelo de partner y hacer solicitudes de predicción

En la Google Cloud consola, ve a la página Model Garden y usa el filtro Colecciones de modelos para ver los Modelos de partners de autodespliegue. Elige uno de los modelos de partners de implementación automática de la lista y cómpralo haciendo clic en Habilitar.

Debes implementar los tipos de máquina que requiera el partner, tal como se describe en la sección "Configuración de hardware recomendada" de la tarjeta del modelo en Model Garden. Una vez implementados, los recursos de servicio del modelo se encuentran en un proyecto seguro gestionado por Google.

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.

En el código, sustituya los siguientes marcadores de posición:

  • LOCATION: la región en la que tienes previsto desplegar el modelo y el endpoint.
  • PROJECT_ID: tu ID de proyecto.
  • DISPLAY_NAME: nombre descriptivo del recurso asociado.
  • PUBLISHER_NAME: Nombre del partner que proporciona el modelo para subirlo o implementarlo.
  • PUBLISHER_MODEL_NAME: nombre del modelo que se va a subir.
  • MACHINE_TYPE: define el conjunto de recursos que se van a implementar para tu modelo, como g2-standard-4. Debes coincidir con una de las configuraciones proporcionadas por el partner.
  • 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. Debes coincidir con una de las configuraciones proporcionadas por el partner.
  • ACCELERATOR_COUNT: número de aceleradores que se van a usar. Debes coincidir con una de las configuraciones proporcionadas por el partner.
  • REQUEST_PAYLOAD: los campos y valores que se incluirán en la solicitud de predicción. Consulta la tarjeta del modelo de Model Garden del partner para ver los campos disponibles.
from google.cloud import aiplatform

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

# Upload a model
model = aiplatform.Model.upload(
    display_name=&quot;DISPLAY_NAME_MODEL",
    model_garden_source_model_name = f&quot;publishers/PUBLISHER_NAME/models/PUBLISHER_MODEL_NAME",
)

# Create endpoint
my_endpoint = aiplatform.Endpoint.create(display_name=&quot;DISPLAY_NAME_ENDPOINT")

# Deploy model
MACHINE_TYPE = "MACHINE_TYPE"  # @param {type: "string"}
ACCELERATOR_TYPE = "ACCELERATOR_TYPE" # @param {type: "string"}
ACCELERATOR_COUNT = ACCELERATOR_COUNT # @param {type: "number&quot;}

model.deploy(
    endpoint=my_endpoint,
    deployed_model_display_name="DISPLAY_NAME_DEPLOYED_MODEL",
    traffic_split={"0": 100},
    machine_type=MACHINE_TYPE,
    accelerator_type=ACCELERATOR_TYPE,
    accelerator_count=ACCELERATOR_COUNT,
    min_replica_count=1,
    max_replica_count=1,
)

# Unary call for predictions
PAYLOAD = {
    REQUEST_PAYLOAD
}

request = json.dumps(PAYLOAD)

response = my_endpoint.raw_predict(
    body = request,
    headers = {';Content-Type&#39;:'application/json'}
)

print(response)

# Streaming call for predictions
PAYLOAD = {
    REQUEST_PAYLOAD
}

request = json.dumps(PAYLOAD)

for stream_response in my_endpoint.stream_raw_predict(
    body = request,
    headers = {'Content-Type':'application/json'}
):
    print(stream_response)

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.

En los comandos curl de ejemplo, sustituye los siguientes marcadores de posición:

  • LOCATION: la región en la que tienes previsto desplegar el modelo y el endpoint.
  • PROJECT_ID: tu ID de proyecto.
  • DISPLAY_NAME: nombre descriptivo del recurso asociado.
  • PUBLISHER_NAME: Nombre del partner que proporciona el modelo para subirlo o implementarlo.
  • PUBLISHER_MODEL_NAME: nombre del modelo que se va a subir.
  • ENDPOINT_ID: ID del endpoint.
  • MACHINE_TYPE: define el conjunto de recursos que se van a implementar para tu modelo, como g2-standard-4. Debes coincidir con una de las configuraciones proporcionadas por el partner.
  • 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. Debes coincidir con una de las configuraciones proporcionadas por el partner.
  • ACCELERATOR_COUNT: número de aceleradores que se van a usar. Debes coincidir con una de las configuraciones proporcionadas por el partner.
  • REQUEST_PAYLOAD: los campos y valores que se incluirán en la solicitud de predicción. Consulta la tarjeta del modelo de Model Garden del partner para ver los campos disponibles.

  1. Sube un modelo para añadirlo a tu registro de modelos.

    curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json"; \
https://LOCATION-aiplatform.googleapi.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/models:upload \
-d '{
";model": {
  "displayName": "DISPLAY_NAME_MODEL",
  "baseModelSource": {
    "modelGardenSource": {
      "publicModelName": f"publishers/PUBLISHER_NAME/models/PUBLISHER_MODEL_NAME",
    }
  }
}
}'

  2. Crea un endpoint.

    curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json"; \
https://LOCATION-aiplatform.googleapi.com/v1/projects/PROJECT_ID/locations/LOCATION/endpoints \
-d '{
"displayName&quot;: "DISPLAY_NAME_ENDPOINT"
}'

  3. Despliega el modelo subido en el endpoint.

    curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json"; \
https://LOCATION-aiplatform.googleapi.com/v1/projects/PROJECT_ID/locations/LOCATION/endpoints/ENDPOINT_ID:deployModel \
-d '{
"deployedModel": {
  "model&quot;: f&quot;projects/PROJECT_ID/locations/LOCATION/models/MODEL_ID",
  "displayName": "DISPLAY_NAME_DEPLOYED_MODEL&quot;,
  &quot;dedicatedResources": {
   "machineSpec": {
      "machineType": "MACHINE_TYPE",
      "acceleratorType": "ACCELERATOR_TYPE",
      &quot;acceleratorCount":"ACCELERATOR_COUNT",
   },
   "minReplicaCount": 1,
   "maxReplicaCount": 1
  },
},
"trafficSplit": {
  "0": 100
}
}'

  4. Una vez que se haya implementado el modelo, podrás hacer una llamada unaria o de streaming para obtener predicciones. Consulta la tarjeta de modelo de Model Garden del partner para ver qué métodos de la API se admiten.

    • Ejemplo de llamada unaria:
    curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json"; \
https://LOCATION-aiplatform.googleapi.com/v1/projects/PROJECT_ID/locations/LOCATION/endpoints/ENDPOINT_ID:rawPredict \
-d 'REQUEST_PAYLOAD'
    • Ejemplo de llamada de streaming:
    curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json"; \
https://LOCATION-aiplatform.googleapi.com/v1/projects/PROJECT_ID/locations/LOCATION/endpoints/ENDPOINT_ID:streamRawPredict \
-d 'REQUEST_PAYLOAD'

Consola

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

    Ir a Model Garden

  2. Para encontrar un modelo específico, introduce su nombre en el cuadro de búsqueda de Model Garden.

  3. Para ver todos los modelos que puede implementar por su cuenta, en la sección Colecciones de modelos del panel de filtros, seleccione Modelos de partners de implementación automática. La lista resultante incluye todos los modelos de partner que se pueden implementar por sí mismos.

  4. Haga clic en el nombre del modelo que quiera implementar para abrir su tarjeta de modelo.

  5. Haz clic en Opciones de implementación.

  6. En el panel Desplegar en Vertex AI, configura el despliegue, como la ubicación y el tipo de máquina.

  7. Haz clic en Desplegar.

Una vez completado el despliegue, puedes solicitar predicciones mediante el SDK o la API. Encontrará instrucciones adicionales en la sección "Documentación" de la tarjeta del modelo.

Ver o gestionar un endpoint

Para ver y gestionar tu endpoint, ve a la página Predicción online de Vertex AI.

Ir a Predicción online

Vertex AI muestra todos los endpoints de tu proyecto de una región concreta. Haz clic en un endpoint para ver sus detalles, como los modelos que se han desplegado en él.

Anular el despliegue de modelos y eliminar recursos

Para evitar que un modelo desplegado use recursos de tu proyecto, anula el despliegue del modelo desde su endpoint. Para poder eliminar un punto final y un modelo, primero debes anular el despliegue del modelo.

Anular despliegues de modelos

Anula el despliegue de un modelo de su endpoint.

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.

En tu código, sustituye lo siguiente:

  • PROJECT_ID con el ID de tu proyecto
  • LOCATION con tu región, por ejemplo, "us-central1"
  • ENDPOINT_ID con el ID de tu endpoint
from google.cloud import aiplatform

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

# To find out which endpoints are available, un-comment the line below:
# endpoints = aiplatform.Endpoint.list()

endpoint = aiplatform.Endpoint(ENDPOINT_ID)
endpoint.undeploy_all()

gcloud

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
  • MODEL_ID con el ID del modelo del comando de modelo de lista
  • DEPLOYED_MODEL_ID con el ID del modelo desplegado

  1. Para encontrar el ID de endpoint asociado a tu implementación, ejecuta el comando gcloud ai endpoints list.

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

  2. Para encontrar el ID del modelo, ejecuta el comando gcloud ai models list.

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

  3. Usa el ID del modelo del comando anterior para obtener el ID del modelo implementado ejecutando el comando gcloud ai models describe.

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

    La salida abreviada tiene un aspecto similar al siguiente ejemplo. 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
...

  4. Ejecuta el comando gcloud ai endpoints undeploy-model para retirar el modelo del endpoint. Para ello, usa el ID del endpoint y el ID del modelo implementado 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.

Consola

  1. En la Google Cloud consola, ve a la pestaña Endpoints (Endpoints) de la página Online prediction (Predicción online).

    Ir a Endpoints

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

  3. Haz clic en el nombre del endpoint para abrir la página de detalles.

  4. En la fila del modelo, haga clic en Acciones y, a continuación, seleccione Retirar modelo del endpoint.

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

Eliminar puntos finales

Elimina el endpoint de Vertex AI asociado a tu despliegue del modelo.

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.

En tu código, sustituye lo siguiente:

  • PROJECT_ID con el ID de tu proyecto
  • LOCATION con tu región, por ejemplo, "us-central1"
  • ENDPOINT_ID con el ID de tu endpoint
from google.cloud import aiplatform

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

# To find out which endpoints are available, un-comment the line below:
# endpoints = aiplatform.Endpoint.list()

endpoint = aiplatform.Endpoint(ENDPOINT_ID)
endpoint.delete()

gcloud

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

  1. Obtén el ID del endpoint que quieras eliminar ejecutando el comando gcloud ai endpoints list. Este comando muestra los IDs de endpoint de todos los endpoints de tu proyecto.

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

  2. 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.

Consola

  1. En la Google Cloud consola, ve a la pestaña Endpoints (Endpoints) de la página Online prediction (Predicción online).

    Ir a Endpoints

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

  3. Al final de la fila del endpoint, haga clic en Acciones y, a continuación, seleccione Eliminar endpoint.

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

Eliminar modelos

Elimina el recurso de modelo asociado a tu despliegue de modelo.

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.

En tu código, sustituye lo siguiente:

  • PROJECT_ID con el ID de tu proyecto
  • LOCATION con tu región, por ejemplo, "us-central1"
  • MODEL_ID con tu ID de modelo
from google.cloud import aiplatform

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

# To find out which models are available in Model Registry, un-comment the line below:
# models = aiplatform.Model.list()

model = aiplatform.Model(MODEL_ID)
model.delete()

gcloud

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
  • MODEL_ID con el ID del modelo del comando de modelo de lista

  1. Para encontrar el ID del modelo que quieres eliminar, ejecuta el comando gcloud ai models list.

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

  2. Ejecuta el comando gcloud ai models delete para eliminar el modelo. Para ello, proporciona el ID del modelo y su ubicación.

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

Consola

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

    Ve a la página Registro de modelos.

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

  3. En la fila de tu modelo, haz clic en Acciones y, a continuación, selecciona Eliminar modelo.

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

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

Ver códigos de ejemplo

La mayoría de las tarjetas de modelo de los modelos de soluciones específicas para tareas contienen ejemplos de código que puedes copiar y probar.

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

    Ir a Model Garden

  2. Busca un modelo admitido del que quieras ver ejemplos de código y haz clic en la pestaña Documentación.

  3. La página se desplazará hasta la sección de documentación con el código de ejemplo insertado.

Crear una aplicación de visión

Las tarjetas de modelo de los modelos de visión artificial aplicables admiten la creación de una aplicación de visión.

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

    Ir a Model Garden

  2. Busca un modelo de visión en la sección Soluciones específicas para tareas que quieras usar para crear una aplicación de visión y haz clic en Ver detalles.

  3. Haz clic en Crear aplicación.

    Se te redirigirá a Vertex AI Vision.

  4. En Nombre de la aplicación, escribe el nombre que quieres darle a la aplicación y haz clic en Continuar.

  5. Selecciona un plan de facturación y haz clic en Crear.

    Se te dirigirá a Vertex AI Vision Studio, donde podrás seguir creando tu aplicación de visión artificial.