Esta página foi traduzida pela API Cloud Translation.

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

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 Google Cloud, consulte a vista geral do SDK de IA gen da Google ou instale a CLI 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.

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', ...]

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 {
#     ...
#   }
#   ...
# ]

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.

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.

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.
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
```
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=can_deploy(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

Nota: O comando seguinte pressupõe que tem sessão iniciada na CLI gcloud com a sua conta de utilizador executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que inicia automaticamente sessão na CLI gcloud. Pode verificar a conta atualmente ativa executando o comando gcloud auth list.

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

Nota: O comando seguinte pressupõe que iniciou sessão na CLI do Google Cloud com a sua conta de utilizador executando gcloud init ou gcloud auth login .gcloud Pode verificar a conta atualmente ativa executando o comando gcloud auth list.

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

Na Google Cloud consola, aceda à página Model Garden.

Aceda ao Model Garden
Encontre um modelo suportado que quer implementar e clique no respetivo cartão de modelo.
Clique em Implementar para abrir o painel Implementar modelo.
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: o 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.
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

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

Implemente e faça inferência do Gemma através do Model Garden e dos pontos finais com suporte de GPU do Vertex AI Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Implemente o Gemma através do Model Garden

Python

gcloud

REST

Apresente os modelos que pode implementar

curl

PowerShell

Implemente um modelo

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

curl

PowerShell

Implemente um modelo do Hugging Face

curl

PowerShell

Implemente um modelo com personalizações

curl

PowerShell

Consola

Terraform

Implemente um modelo

Aplique a configuração

Limpar

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

Parâmetros de código

Consola

gcloud

Exemplo de código

Python

Node.js

Java

Go

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