Implemente e faça inferência do Gemma através do Model Garden e dos pontos finais com suporte de GPU do Vertex AI

Neste tutorial, vai usar o Model Garden para implementar o modelo aberto Gemma 1B num ponto final do Vertex AI com tecnologia de GPU. Tem de implementar um modelo num ponto final antes de poder usar esse modelo para publicar previsões online. A implementação de um modelo associa recursos físicos ao modelo para que possa publicar previsões online com baixa latência.

Depois de implementar o modelo Gemma 1B, infere o modelo preparado usando o PredictionServiceClient para obter previsões online. As previsões online são pedidos síncronos feitos a um modelo implementado num ponto final.

Objetivos

Este tutorial mostra como realizar as seguintes tarefas:

  • Implemente o modelo aberto Gemma 1B num ponto final suportado por GPU através do Model Garden
  • Use o PredictionServiceClient para receber previsões online

Custos

Neste documento, usa os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custos com base na sua utilização projetada, use a calculadora de preços.

Os novos Google Cloud utilizadores podem ser elegíveis para uma avaliação gratuita.

Quando terminar as tarefas descritas neste documento, pode evitar a faturação contínua eliminando os recursos que criou. Para mais informações, consulte o artigo Limpe.

Antes de começar

Este tutorial requer que:

  • Configure um Google Cloud projeto e ative a API Vertex AI
  • Na sua máquina local:
    • Instale, inicialize e faça a autenticação com a CLI Google Cloud
    • Instale o SDK para o seu idioma

Configure um Google Cloud projeto

Configure o seu Google Cloud projeto e ative a 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.

    Configure a CLI Google Cloud

    Na sua máquina local, configure a CLI Google Cloud.

    1. Instale e inicialize a CLI Google Cloud.

    2. Se instalou anteriormente a CLI gcloud, certifique-se de que os componentes gcloud estão atualizados executando este comando.

      gcloud components update

    3. Para se autenticar com a CLI gcloud, execute este comando para gerar um ficheiro de Credenciais padrão da aplicação (ADC) local. O fluxo da Web iniciado pelo comando é usado para fornecer as suas credenciais de utilizador.

      gcloud auth application-default login

      Para mais informações, consulte a configuração de autenticação da CLI gcloud e a configuração do ADC.

    Configure o SDK para a sua linguagem de programação

    Para configurar o ambiente usado neste tutorial, instala o SDK do Vertex AI para o seu idioma e a biblioteca Protocol Buffers. Os exemplos de código usam funções da biblioteca de buffers de protocolo para converter o dicionário de entrada no formato JSON esperado pela API.

    Na sua máquina local, clique num dos seguintes separadores para instalar o SDK para o seu idioma de programação.

    Python

    Na sua máquina local, clique num dos seguintes separadores para instalar o SDK para a sua linguagem de programação.

    • Instale e atualize o SDK Vertex AI para Python executando este comando.

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

    • Instale a biblioteca Protocol Buffers para Python executando este comando.

      pip3 install --upgrade "protobuf>=5.28"

    Node.js

    Instale ou atualize o SDK aiplatform para Node.js executando o seguinte comando.

    npm install @google-cloud/aiplatform

    Java

    Para adicionar google-cloud-aiplatform como uma dependência, adicione o código adequado para o seu ambiente.

    Maven com BOM

    Adicione o seguinte HTML ao seu 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 sem BOM

    Adicione o seguinte ao seu 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 sem BOM

    Adicione o seguinte ao seu build.gradle:

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

    Go

    Instale estes pacotes Go executando os seguintes comandos.

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

    Implemente o Gemma através do Model Garden

    Pode implementar o Gemma 1B através do respetivo cartão de modelo na Google Cloud consola ou por programação.

    Para mais informações sobre a configuração do SDK de IA gen da Google ou da CLI do Google Cloud, consulte a vista geral do SDK de IA gen da Google ou instale a CLI do Google Cloud.

    Python

    Para saber como instalar ou atualizar o SDK Vertex AI para Python, consulte o artigo Instale o SDK Vertex AI para Python. Para mais informações, consulte a Python documentação de referência da API.

    1. Liste os modelos que pode implementar e registe o ID do modelo a implementar. Opcionalmente, pode listar os modelos do Hugging Face suportados no Model Garden e até filtrá-los por nomes de modelos. O resultado não inclui modelos otimizados.

      
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. Veja as especificações de implementação de um modelo através do ID do modelo do passo anterior. Pode ver o tipo de máquina, o tipo de acelerador e o URI da imagem do contentor que o Model Garden validou para um modelo específico.

      
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. Implemente um modelo num ponto final. O Model Garden usa a configuração de implementação predefinida, a menos que especifique argumentos e valores adicionais.

      
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 começar, especifique um projeto de quota para executar os seguintes comandos. Os comandos que executa são contabilizados nas quotas desse projeto. Para mais informações, consulte o artigo Defina o projeto de quota.

    1. Liste os modelos que pode implementar executando o comando gcloud ai model-garden models list. Este comando lista todos os IDs dos modelos e quais pode implementar autonomamente.

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

      Na saída, encontre o ID do modelo a implementar. O exemplo seguinte mostra um resultado abreviado.

      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

      O resultado não inclui modelos otimizados nem modelos do Hugging Face. Para ver que modelos do Hugging Face são suportados, adicione a flag --can-deploy-hugging-face-models.

    2. Para ver as especificações de implementação de um modelo, execute o comando gcloud ai model-garden models list-deployment-config. Pode ver o tipo de máquina, o tipo de acelerador e o URI da imagem do contentor que o Model Garden suporta para um modelo específico.

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

      Substitua MODEL_ID pelo ID do modelo do comando da lista anterior, como google/gemma@gemma-2b ou stabilityai/stable-diffusion-xl-base-1.0.

    3. Implemente um modelo num ponto final executando o comando gcloud ai model-garden models deploy. O Model Garden gera um nome a apresentar para o seu ponto final e usa a configuração de implementação predefinida, a menos que especifique argumentos e valores adicionais.

      Para executar o comando de forma assíncrona, inclua a flag --asynchronous.

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

      Substitua os seguintes marcadores de posição:

      • MODEL_ID: o ID do modelo do comando de lista anterior. Para os modelos da Hugging Face, use o formato de URL do modelo da Hugging Face, como stabilityai/stable-diffusion-xl-base-1.0.
      • MACHINE_TYPE: define o conjunto de recursos a implementar para o seu modelo, como g2-standard-4.
      • ACCELERATOR_TYPE: especifica os aceleradores a adicionar à sua implementação para ajudar a melhorar o desempenho quando trabalha com cargas de trabalho intensivas, como NVIDIA_L4.
      • ENDPOINT_NAME: um nome para o ponto final do Vertex AI implementado.
      • HF_ACCESS_TOKEN: para modelos do Hugging Face, se o modelo for restrito, faculte um token de acesso.
      • RESERVATION_RESOURCE_NAME: Para usar uma reserva do Compute Engine específica, especifique o nome da sua reserva. Se especificar uma reserva específica, não pode especificar any-reservation.

      O resultado inclui a configuração de implementação usada pelo Model Garden, o ID do ponto final e o ID da operação de implementação, que pode usar para verificar o estado da implementação.

      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 detalhes sobre a sua implementação, execute o comando gcloud ai endpoints list --list-model-garden-endpoints-only:

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

      Substitua LOCATION_ID pela região onde implementou o modelo.

      A saída inclui todos os pontos finais criados a partir do Model Garden e inclui informações como o ID do ponto final, o nome do ponto final e se o ponto final está associado a um modelo implementado. Para encontrar a sua implementação, procure o nome do ponto final devolvido pelo comando anterior.

    REST

    Apresente todos os modelos implementáveis e, em seguida, obtenha o ID do modelo a implementar. Em seguida, pode implementar o modelo com a respetiva configuração e ponto final predefinidos. Em alternativa, pode optar por personalizar a implementação, como definir um tipo de máquina específico ou usar um ponto final dedicado.

    Apresente os modelos que pode implementar

    Antes de usar qualquer um dos dados do pedido, faça as seguintes substituições:

    • PROJECT_ID: o ID do seu Google Cloud projeto.
    • QUERY_PARAMETERS: para listar os modelos do Model Garden, adicione os seguintes parâmetros de consulta: listAllVersions=True&filter=is_deployable(true). Para listar os modelos do Hugging Face, defina o filtro como alt=json&is_hf_wildcard(true)+AND+labels.VERIFIED_DEPLOYMENT_CONFIG%3DVERIFIED_DEPLOYMENT_SUCCEED&listAllVersions=True.

    Método HTTP e URL: 

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

    Para enviar o seu pedido, escolha uma destas opções:

    curl

    Execute o seguinte comando: 

    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

    Execute o seguinte comando: 

    $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

    Recebe uma resposta JSON semelhante à seguinte.

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

    Implemente um modelo

    Implemente um modelo do Model Garden ou um modelo do Hugging Face. Também pode personalizar a implementação especificando campos JSON adicionais.

    Implemente um modelo com a respetiva configuração predefinida.

    Antes de usar qualquer um dos dados do pedido, faça as seguintes substituições:

    • LOCATION: uma região onde o modelo é implementado.
    • PROJECT_ID: o ID do seu Google Cloud projeto.
    • MODEL_ID: o ID do modelo a implementar, que pode obter ao listar todos os modelos implementáveis. O ID usa o seguinte formato: publishers/PUBLISHER_NAME/models/ MODEL_NAME@MODEL_VERSION.

    Método HTTP e URL: 

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

    Corpo JSON do pedido: 

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

    Para enviar o seu pedido, escolha uma destas opções:

    curl

    Guarde o corpo do pedido num ficheiro denominado request.json. Execute o seguinte comando no terminal para criar ou substituir este ficheiro no diretório atual: 

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

    Em seguida, execute o seguinte comando para enviar o seu pedido 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

    Guarde o corpo do pedido num ficheiro denominado request.json. Execute o seguinte comando no terminal para criar ou substituir este ficheiro no diretório atual: 

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

    Em seguida, execute o seguinte comando para enviar o seu pedido 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

    Recebe uma resposta JSON semelhante à seguinte.

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

    Implemente um modelo do Hugging Face

    Antes de usar qualquer um dos dados do pedido, faça as seguintes substituições:

    • LOCATION: uma região onde o modelo é implementado.
    • PROJECT_ID: o ID do seu Google Cloud projeto.
    • MODEL_ID: o modelo Hugging Face ID do modelo a implementar, que pode obter a partir da listagem de todos os modelos implementáveis. O ID usa o seguinte formato: PUBLISHER_NAME/MODEL_NAME.
    • ACCESS_TOKEN: se o modelo for restrito, forneça um token de acesso.

    Método HTTP e URL: 

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

    Corpo JSON do pedido: 

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

    Para enviar o seu pedido, escolha uma destas opções:

    curl

    Guarde o corpo do pedido num ficheiro denominado request.json. Execute o seguinte comando no terminal para criar ou substituir este ficheiro no diretório atual: 

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

    Em seguida, execute o seguinte comando para enviar o seu pedido 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

    Guarde o corpo do pedido num ficheiro denominado request.json. Execute o seguinte comando no terminal para criar ou substituir este ficheiro no diretório atual: 

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

    Em seguida, execute o seguinte comando para enviar o seu pedido 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

    Recebe uma resposta JSON semelhante à seguinte.

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

    Implemente um modelo com personalizações

    Antes de usar qualquer um dos dados do pedido, faça as seguintes substituições:

    • LOCATION: uma região onde o modelo é implementado.
    • PROJECT_ID: o ID do seu Google Cloud projeto.
    • MODEL_ID: o ID do modelo a implementar, que pode obter ao listar todos os modelos implementáveis. O ID usa o seguinte formato: publishers/PUBLISHER_NAME/models/ MODEL_NAME@MODEL_VERSION, como google/gemma@gemma-2b ou stabilityai/stable-diffusion-xl-base-1.0.
    • MACHINE_TYPE: define o conjunto de recursos a implementar para o seu modelo, como g2-standard-4.
    • ACCELERATOR_TYPE: Especifica aceleradores a adicionar à sua implementação para ajudar a melhorar o desempenho quando trabalha com cargas de trabalho intensivas, como NVIDIA_L4
    • ACCELERATOR_COUNT: o número de aceleradores a usar na sua implementação.
    • reservation_affinity_type: Para usar uma reserva do Compute Engine existente para a sua implementação, especifique qualquer reserva ou uma específica. Se especificar este valor, não especifique spot.
    • spot: se deve usar VMs do Spot para a sua implementação.
    • IMAGE_URI: a localização da imagem do contentor a usar, como us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20241016_0916_RC00_maas
    • CONTAINER_ARGS: argumentos a transmitir ao contentor durante a implementação.
    • CONTAINER_PORT: um número de porta para o seu contentor.
    • fast_tryout_enabled: Quando testa um modelo, pode optar por usar uma implementação mais rápida. Esta opção só está disponível para os modelos muito usados com determinados tipos de máquinas. Se estiver ativado, não pode especificar configurações de modelos nem de implementação.

    Método HTTP e URL: 

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

    Corpo JSON do pedido: 

    {
  "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 o seu pedido, escolha uma destas opções:

    curl

    Guarde o corpo do pedido num ficheiro denominado request.json. Execute o seguinte comando no terminal para criar ou substituir este ficheiro no diretório atual: 

    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

    Em seguida, execute o seguinte comando para enviar o seu pedido 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

    Guarde o corpo do pedido num ficheiro denominado request.json. Execute o seguinte comando no terminal para criar ou substituir este ficheiro no diretório atual: 

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

    Em seguida, execute o seguinte comando para enviar o seu pedido 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

    Recebe uma resposta JSON semelhante à seguinte.

    {
  "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. Na Google Cloud consola, aceda à página Model Garden.

      Aceda ao Model Garden

    2. Encontre um modelo suportado que quer implementar e clique no respetivo cartão de modelo.

    3. Clique em Implementar para abrir o painel Implementar modelo.

    4. No painel Implementar modelo, especifique os detalhes da implementação.

      1. Usar ou modificar os nomes do modelo e do ponto final gerados.
      2. Selecione uma localização para criar o seu ponto final do modelo.
      3. Selecione um tipo de máquina a usar para cada nó da sua implementação.

      4. Para usar uma reserva do Compute Engine, na secção Definições de implementação, selecione Avançadas.

        No campo Tipo de reserva, selecione um tipo de reserva. A reserva tem de corresponder às especificações da máquina indicadas.

        • Usar automaticamente a reserva criada: a Vertex AI seleciona automaticamente uma reserva permitida com propriedades correspondentes. Se não houver capacidade na reserva selecionada automaticamente, o Vertex AI usa o conjunto de recursos Google Cloudgeral.
        • Selecionar reservas específicas: a Vertex AI usa uma reserva específica. Se não houver capacidade para a reserva selecionada, é apresentado um erro.
        • Não usar (predefinição): o Vertex AI usa o conjunto de recursosGoogle Cloud geral. Este valor tem o mesmo efeito que não especificar uma reserva.

    5. Clique em Implementar.

    Terraform

    Para saber como aplicar ou remover uma configuração do Terraform, consulte os comandos básicos do Terraform. Para mais informações, consulte a Terraform documentação de referência do fornecedor.

    Implemente um modelo

    O exemplo seguinte implementa o modelo gemma-3-1b-it num novo ponto final da Vertex AI em us-central1 através das configurações predefinidas.

    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 implementar um modelo com personalização, consulte o artigo Ponto final da Vertex AI com implementação do Model Garden para ver detalhes.

    Aplique a configuração

    terraform init
terraform plan
terraform apply

    Depois de aplicar a configuração, o Terraform aprovisiona um novo ponto final da Vertex AI e implementa o modelo aberto especificado.

    Limpar

    Para eliminar o ponto final e a implementação do modelo, execute o seguinte comando:

    terraform destroy

    Faça inferência do Gemma 1B com o PredictionServiceClient

    Depois de implementar o Gemma 1B, usa a PredictionServiceClient para obter previsões online para o comando: "Porque é que o céu é azul?"

    Parâmetros de código

    Os PredictionServiceClient exemplos de código requerem que atualize o seguinte.

    • PROJECT_ID: para encontrar o ID do projeto, siga estes passos.

      1. Aceda à página Boas-vindas na Google Cloud consola.

        Aceder a Boas-vindas

      2. No seletor de projetos na parte superior da página, selecione o seu projeto.

        O nome do projeto, o número do projeto e o ID do projeto aparecem após o cabeçalho Bem-vindo.

    • ENDPOINT_REGION: esta é a região onde implementou o ponto final.

    • ENDPOINT_ID: para encontrar o ID do ponto final, veja-o na consola ou execute o comando gcloud ai endpoints list. Precisa do nome do ponto final e da região do painel Implementar modelo.

      Consola

      Pode ver os detalhes do ponto final clicando em Previsão online > Pontos finais e selecionando a sua região. Tenha em atenção o número apresentado na coluna ID.

      Aceda a Pontos finais

      gcloud

      Pode ver os detalhes do ponto final executando o comando gcloud ai endpoints list.

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

      O resultado tem o seguinte aspeto.

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

    Exemplo de código

    No exemplo de código para o seu idioma, atualize os valores PROJECT_ID, ENDPOINT_REGION e ENDPOINT_ID. Em seguida, execute o código.

    Python

    Para saber como instalar ou atualizar o SDK Vertex AI para Python, consulte o artigo Instale o SDK Vertex AI para Python. Para mais informações, consulte a Python documentação de referência da API. 

    """
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 experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Node.js Vertex AI.

    Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento 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 experimentar este exemplo, siga as Javainstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Java Vertex AI.

    Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento 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 experimentar este exemplo, siga as Goinstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Go Vertex AI.

    Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento 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
}

    Limpar

    Para evitar incorrer em custos na sua conta do Google Cloud pelos recursos usados neste tutorial, elimine o projeto que contém os recursos ou mantenha o projeto e elimine os recursos individuais.

    Elimine o projeto

    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.

    Elimine recursos individuais

    Se vai manter o projeto, elimine os recursos usados neste tutorial:

    • Anule a implementação do modelo e elimine o ponto final
    • Elimine o modelo do registo de modelos

    Anule a implementação do modelo e elimine o ponto final

    Use um dos seguintes métodos para anular a implementação de um modelo e eliminar o ponto final.

    Consola

    1. Na Google Cloud consola, clique em Previsão online e, de seguida, clique em Pontos finais.

      Aceda à página Pontos finais

    2. Na lista pendente Região, escolha a região onde implementou o seu ponto final.

    3. Clique no nome do ponto final para abrir a página de detalhes. Por exemplo: gemma2-2b-it-mg-one-click-deploy.

    4. Na linha do modelo Gemma 2 (Version 1), clique em Ações e, de seguida, clique em Anular implementação do modelo a partir do ponto final.

    5. Na caixa de diálogo Anular implementação do modelo a partir do ponto final, clique em Anular implementação.

    6. Clique no botão Anterior para voltar à página Pontos finais.

      Aceda à página Pontos finais

    7. No final da linha gemma2-2b-it-mg-one-click-deploy, clique em Ações e, de seguida, selecione Eliminar ponto final.

    8. No comando de confirmação, clique em Confirmar.

    gcloud

    Para anular a implementação do modelo e eliminar o ponto final através da Google Cloud CLI, siga estes passos.

    Nestes comandos, substitua:

    • PROJECT_ID com o nome do seu projeto
    • LOCATION_ID com a região onde implementou o modelo e o ponto final
    • ENDPOINT_ID com o ID de ponto final
    • DEPLOYED_MODEL_NAME com o nome a apresentar do modelo
    • DEPLOYED_MODEL_ID com o ID do modelo

    1. Execute o comando gcloud ai endpoints list para obter o ID do ponto final. Este comando lista os IDs dos pontos finais de todos os pontos finais no seu projeto. Tome nota do ID do ponto final usado neste tutorial.

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

      O resultado tem o seguinte aspeto. Na saída, o ID é denominado ENDPOINT_ID.

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

    2. Execute o comando gcloud ai models describe para obter o ID do modelo. Tome nota do ID do modelo que implementou neste tutorial.

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

      O resultado abreviado tem o seguinte aspeto. Na saída, o ID é denominado 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. Anule a implementação do modelo no ponto final. Precisa do ID do ponto final e do ID do modelo dos comandos anteriores.

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

      Este comando não produz qualquer resultado.

    4. Execute o comando gcloud ai endpoints delete para eliminar o ponto final.

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

      Quando lhe for pedido, escreva y para confirmar. Este comando não produz qualquer resultado.

    Elimine o modelo

    Consola

    1. Aceda à página Registo de modelos na secção Vertex AI da Google Cloud consola.

      Aceda à página Registo de modelos

    2. Na lista pendente Região, escolha a região onde implementou o modelo.

    3. No final da linha gemma2-2b-it-1234567891234, clique em Ações.

    4. Selecione Eliminar modelo.

      Quando elimina o modelo, todas as versões e avaliações do modelo associadas são eliminadas do seu Google Cloud projeto.

    5. Na mensagem de confirmação, clique em Eliminar.

    gcloud

    Para eliminar o modelo através da CLI Google Cloud, indique o nome a apresentar e a região do modelo no comando gcloud ai models delete.

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

    Substitua DEPLOYED_MODEL_NAME pelo nome a apresentar do modelo. Substitua PROJECT_ID pelo nome do seu projeto. Substitua LOCATION_ID pela região onde implementou o modelo.

    O que se segue?