Questa pagina è stata tradotta dall'API Cloud Translation.

Esegui il deployment e l'inferenza di Gemma utilizzando gli endpoint basati su GPU di Model Garden e Vertex AI

In questo tutorial viene utilizzato Model Garden per eseguire il deployment del modello aperto Gemma 1B in un endpoint Vertex AI supportato da GPU. Devi eseguire il deployment di un modello in un endpoint prima di poterlo utilizzare per fornire previsioni online. Il deployment di un modello associa risorse fisiche al modello in modo che possa fornire previsioni online con bassa latenza.

Dopo aver eseguito il deployment del modello Gemma 1B, esegui l'inferenza del modello addestrato utilizzando PredictionServiceClient per ottenere previsioni online. Le previsioni online sono richieste sincrone effettuate a un modello di cui è stato eseguito il deployment in un endpoint.

Obiettivi

Questo tutorial mostra come eseguire le seguenti attività:

Esegui il deployment del modello aperto Gemma 1B in un endpoint supportato da GPU utilizzando Model Garden
Utilizzare PredictionServiceClient per ottenere previsioni online

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova senza costi.

Al termine delle attività descritte in questo documento, puoi evitare l'addebito di ulteriori costi eliminando le risorse che hai creato. Per ulteriori informazioni, vedi Pulizia.

Prima di iniziare

Questo tutorial richiede di:

Configurare un progetto Google Cloud e abilitare l'API Vertex AI
Sulla macchina locale:
- Installa, inizializza ed esegui l'autenticazione con Google Cloud CLI
- Installa l'SDK per la tua lingua

Configurare un progetto Google Cloud

Configura il tuo progetto Google Cloud e abilita l'API Vertex AI.

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.

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

Verify that billing is enabled for your Google Cloud project.

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

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

Verify that billing is enabled for your Google Cloud project.

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

Configura Google Cloud CLI

Sulla tua macchina locale, configura Google Cloud CLI.

Installa e inizializza Google Cloud CLI.
Se hai già installato gcloud CLI, assicurati che i componenti gcloud siano aggiornati eseguendo questo comando.
```
gcloud components update
```
Per l'autenticazione con l'interfaccia alla gcloud CLI, genera un file Credenziali predefinite dell'applicazione (ADC) locale eseguendo questo comando. Il flusso web avviato dal comando viene utilizzato per fornire le credenziali utente.
```
gcloud auth application-default login
```
Per ulteriori informazioni, consulta Configurazione dell'autenticazione dell'interfaccia a riga di comando gcloud e configurazione di ADC.

Configura l'SDK per il tuo linguaggio di programmazione

Per configurare l'ambiente utilizzato in questo tutorial, installa l'SDK Vertex AI per il tuo linguaggio e la libreria Protocol Buffers. Gli esempi di codice utilizzano funzioni della libreria Protocol Buffers per convertire il dizionario di input nel formato JSON previsto dall'API.

Sulla tua macchina locale, fai clic su una delle seguenti schede per installare l'SDK per il tuo linguaggio di programmazione.

Python

Sulla tua macchina locale, fai clic su una delle seguenti schede per installare l'SDK per il tuo linguaggio di programmazione.

Installa e aggiorna l'SDK Vertex AI per Python eseguendo questo comando.
```
pip3 install --upgrade "google-cloud-aiplatform>=1.64"
```
Installa la libreria Protocol Buffers per Python eseguendo questo comando.
```
pip3 install --upgrade "protobuf>=5.28"
```

Node.js

Installa o aggiorna l'SDK aiplatform per Node.js eseguendo questo comando.

npm install @google-cloud/aiplatform

Java

Per aggiungere google-cloud-aiplatform come dipendenza, aggiungi il codice appropriato per il tuo ambiente.

Maven con BOM

Aggiungi il seguente codice HTML al tuo 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 senza BOM

Aggiungi quanto segue al tuo 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 senza BOM

Aggiungi quanto segue a build.gradle:

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

Vai

Installa questi pacchetti Go eseguendo i seguenti comandi.

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

Esegui il deployment di Gemma utilizzando Model Garden

Puoi eseguire il deployment di Gemma 1B utilizzando la relativa scheda nella console Google Cloud o in modo programmatico.

Per ulteriori informazioni sulla configurazione dell'SDK Google Gen AI o di Google Cloud CLI, consulta la panoramica dell'SDK Google Gen AI o l'articolo Installare Google Cloud CLI.

Python

Per scoprire come installare o aggiornare l'SDK Vertex AI Python, consulta Installare l'SDK Vertex AI Python. Per saperne di più, consulta la documentazione di riferimento dell'API Python.

Elenca i modelli di cui puoi eseguire il deployment e registra l'ID modello da utilizzare. Se vuoi, puoi elencare i modelli Hugging Face supportati in Model Garden e persino filtrarli in base al nome. L'output non include modelli ottimizzati.


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

Visualizza le specifiche di deployment per un modello utilizzando l'ID modello del passaggio precedente. Puoi visualizzare l'URI del tipo di macchina, del tipo di acceleratore e dell'immagine container che Model Garden ha verificato per un determinato modello.


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

Esegui il deployment di un modello su un endpoint. Model Garden utilizza la configurazione di deployment predefinita, a meno che tu non specifichi argomenti e valori aggiuntivi.


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

Prima di iniziare, specifica un progetto di quota per eseguire i seguenti comandi. I comandi che esegui vengono conteggiati in base alle quote per quel progetto. Per ulteriori informazioni, consulta Impostare il progetto di quota.

Elenca i modelli che puoi eseguire il deployment eseguendo il comando gcloud ai model-garden models list. Questo comando elenca tutti gli ID modello e quelli che puoi eseguire autonomamente.

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

Nell'output, trova l'ID modello da eseguire il deployment. L'esempio seguente mostra un output abbreviato.

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

L'output non include modelli ottimizzati o modelli Hugging Face. Per visualizzare i modelli Hugging Face supportati, aggiungi il flag --can-deploy-hugging-face-models.

Per visualizzare le specifiche di deployment di un modello, esegui il comando gcloud ai model-garden models list-deployment-config. Puoi visualizzare il tipo di macchina, il tipo di acceleratore e l'URI dell'immagine container supportati da Model Garden per un determinato modello.
```
gcloud ai model-garden models list-deployment-config \
    --model=MODEL_ID
```
Sostituisci MODEL_ID con l'ID modello dell'elenco precedente comando, ad esempio google/gemma@gemma-2b o stabilityai/stable-diffusion-xl-base-1.0.
Esegui il deployment di un modello in un endpoint eseguendo il comando gcloud ai model-garden models deploy. Model Garden genera un nome visualizzato per l'endpoint e utilizza la configurazione di deployment predefinita, a meno che tu non specifichi argomenti e valori aggiuntivi.

Per eseguire il comando in modo asincrono, includi il 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]
```
Sostituisci i seguenti segnaposto:
- MODEL_ID: L'ID modello del comando di elenco precedente. Per i modelli Hugging Face, utilizza il formato URL del modello Hugging Face, ad esempio stabilityai/stable-diffusion-xl-base-1.0.
- MACHINE_TYPE: definisce l'insieme di risorse da deployment per il modello, ad esempio g2-standard-4.
- ACCELERATOR_TYPE: specifica gli acceleratori da aggiungere al deployment per migliorare le prestazioni quando si lavora con carichi di lavoro intensivi, ad esempio NVIDIA_L4.
- ENDPOINT_NAME: un nome per l'endpoint Vertex AI di cui è stato eseguito il deployment.
- HF_ACCESS_TOKEN: per i modelli Hugging Face, se il modello è protetto, fornisci un token di accesso.
- RESERVATION_RESOURCE_NAME: per utilizzare una prenotazione Compute Engine specifica, specifica il nome della prenotazione. Se specifichi una prenotazione specifica, non puoi specificare any-reservation.
L'output include la configurazione del deployment utilizzata da Model Garden, l'ID endpoint e l'ID operazione di deployment, che puoi utilizzare per controllare lo stato del deployment.
```
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
```
Per visualizzare i dettagli del deployment, esegui il comando gcloud ai endpoints list --list-model-garden-endpoints-only:
```
gcloud ai endpoints list --list-model-garden-endpoints-only \
    --region=LOCATION_ID
```
Sostituisci LOCATION_ID con la regione in cui hai eseguito il deployment del modello.

L'output include tutti gli endpoint creati da Model Garden e include informazioni come l'ID endpoint, il nome dell'endpoint e se l'endpoint è associato a un modello di cui è stato eseguito il deployment. Per trovare il deployment, cerca il nome dell'endpoint restituito dal comando precedente.

REST

Elenca tutti i modelli di cui è possibile eseguire il deployment e poi recupera l'ID del modello di cui eseguire il deployment. Puoi poi eseguire il deployment del modello con la configurazione e l'endpoint predefiniti. In alternativa, puoi scegliere di personalizzare il deployment, ad esempio impostando un tipo di macchina specifico o utilizzando un endpoint dedicato.

Elenca i modelli di cui puoi eseguire il deployment

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

PROJECT_ID: il tuo ID progetto Google Cloud .
QUERY_PARAMETERS: per elencare i modelli di Model Garden, aggiungi i seguenti parametri di ricerca listAllVersions=True&filter=is_deployable(true). Per elencare i modelli Hugging Face, imposta il filtro su alt=json&is_hf_wildcard(true)+AND+labels.VERIFIED_DEPLOYMENT_CONFIG%3DVERIFIED_DEPLOYMENT_SUCCEED&listAllVersions=True.

Metodo HTTP e URL:

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

Per inviare la richiesta, scegli una di queste opzioni:

curl

Nota: il seguente comando presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che consente di accedere automaticamente all'interfaccia a riga di comando gcloud. Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Esegui questo 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: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Esegui questo 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

Ricevi una risposta JSON simile alla seguente.

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

Esegui il deployment di un modello

Esegui il deployment di un modello da Model Garden o di un modello da Hugging Face. Puoi anche personalizzare il deployment specificando campi JSON aggiuntivi.

Esegui il deployment di un modello con la sua configurazione predefinita.

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

LOCATION: una regione in cui è stato eseguito il deployment del modello.
PROJECT_ID: il tuo ID progetto Google Cloud .
MODEL_ID: l'ID del modello da di cui eseguire il deployment, che puoi ottenere elencando tutti i modelli di cui è possibile eseguire il deployment. L'ID utilizza il seguente formato: publishers/PUBLISHER_NAME/models/ MODEL_NAME@MODEL_VERSION.

Metodo HTTP e URL:

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

Corpo JSON della richiesta:

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

Per inviare la richiesta, scegli una di queste opzioni:

curl

Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente:

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

Quindi esegui questo comando per inviare la richiesta 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

Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente:

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

Quindi esegui questo comando per inviare la richiesta 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

Ricevi una risposta JSON simile alla seguente.

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

Esegui il deployment di un modello Hugging Face

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

LOCATION: una regione in cui è stato eseguito il deployment del modello.
PROJECT_ID: il tuo ID progetto Google Cloud .
MODEL_ID: ID modello Hugging Face da implementare, che puoi ottenere elencando tutti i modelli implementabili. L'ID utilizza il seguente formato: PUBLISHER_NAME/MODEL_NAME.
ACCESS_TOKEN: se il modello è protetto, fornisci un token di accesso.

Metodo HTTP e URL:

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

Corpo JSON della richiesta:

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

Per inviare la richiesta, scegli una di queste opzioni:

curl

Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente:

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

Quindi esegui questo comando per inviare la richiesta 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

Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente:

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

Quindi esegui questo comando per inviare la richiesta 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

Ricevi una risposta JSON simile alla seguente.

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

Esegui il deployment di un modello con personalizzazioni

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

LOCATION: una regione in cui è stato eseguito il deployment del modello.
PROJECT_ID: il tuo ID progetto Google Cloud .
MODEL_ID: l'ID del modello da di cui eseguire il deployment, che puoi ottenere elencando tutti i modelli di cui è possibile eseguire il deployment. L'ID utilizza il seguente formato: publishers/PUBLISHER_NAME/models/ MODEL_NAME@MODEL_VERSION, ad esempio google/gemma@gemma-2b o stabilityai/stable-diffusion-xl-base-1.0.
MACHINE_TYPE: definisce l'insieme di risorse da deployment per il modello, ad esempio g2-standard-4.
ACCELERATOR_TYPE: Specifica gli acceleratori da aggiungere al deployment per migliorare le prestazioni quando si lavora con carichi di lavoro intensivi, come NVIDIA_L4
ACCELERATOR_COUNT: Il numero di acceleratori da utilizzare nel deployment.
reservation_affinity_type: per utilizzare una prenotazione Compute Engine esistente per il deployment, specifica una prenotazione o una specifica. Se specifichi questo valore, non specificare spot.
spot: indica se utilizzare le VM spot per il deployment.
IMAGE_URI: la posizione dell'immagine container da utilizzare, ad esempio us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20241016_0916_RC00_maas
CONTAINER_ARGS: Argomenti da passare al container durante il deployment.
CONTAINER_PORT: un numero di porta per il container.
fast_tryout_enabled: quando testi un modello, puoi scegliere di utilizzare un deployment più rapido. Questa opzione è disponibile solo per i modelli più utilizzati con determinati tipi di macchine. Se attivata, non puoi specificare configurazioni di modelli o deployment.

Metodo HTTP e URL:

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

Corpo JSON della richiesta:

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

Per inviare la richiesta, scegli una di queste opzioni:

curl

Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente:

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

Quindi esegui questo comando per inviare la richiesta 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

Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente:

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

Quindi esegui questo comando per inviare la richiesta 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

Ricevi una risposta JSON simile alla seguente.

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

Console

Nella console Google Cloud , vai alla pagina Model Garden.

Vai a Model Garden
Trova un modello supportato di cui vuoi eseguire il deployment e fai clic sulla relativa scheda.
Fai clic su Esegui il deployment per aprire il riquadro Esegui il deployment del modello.
Nel riquadro Esegui il deployment del modello, specifica i dettagli del deployment.
1. Utilizza o modifica i nomi del modello e dell'endpoint generati.
2. Seleziona una località in cui creare l'endpoint del modello.
3. Seleziona un tipo di macchina da utilizzare per ogni nodo del deployment.
4. Per utilizzare una prenotazione Compute Engine, nella sezione Impostazioni di deployment, seleziona Avanzate.
  
  Per il campo Tipo di prenotazione, seleziona un tipo di prenotazione. La prenotazione deve corrispondere alle specifiche della macchina che hai indicato.
  - Utilizza automaticamente la prenotazione creata: Vertex AI seleziona automaticamente una prenotazione consentita con proprietà corrispondenti. Se non è disponibile capacità nella prenotazione selezionata automaticamente, Vertex AI utilizza il pool di risorse Google Cloudgenerale.
  - Seleziona prenotazioni specifiche: Vertex AI utilizza una prenotazione specifica. Se non è disponibile la capacità per la prenotazione selezionata, viene generato un errore.
  - Non utilizzare (impostazione predefinita): Vertex AI utilizza il pool di risorseGoogle Cloud generale. Questo valore ha lo stesso effetto della mancata specifica di una prenotazione.
Fai clic su Esegui il deployment.

Terraform

Per scoprire come applicare o rimuovere una configurazione Terraform, consulta Comandi Terraform di base. Per saperne di più, consulta la documentazione di riferimento del fornitore Terraform.

Esegui il deployment di un modello

L'esempio seguente esegue il deployment del modello gemma-3-1b-it su un nuovo endpoint Vertex AI in us-central1 utilizzando le configurazioni predefinite.

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

Per eseguire il deployment di un modello con personalizzazione, consulta Endpoint Vertex AI con deployment di Model Garden per i dettagli.

Applica la configurazione

terraform init
terraform plan
terraform apply

Dopo aver applicato la configurazione, Terraform esegue il provisioning di un nuovo endpoint Vertex AI e implementa il modello open source specificato.

Esegui la pulizia

Per eliminare il deployment dell'endpoint e del modello, esegui questo comando:

terraform destroy

Inferenza di Gemma 1B con PredictionServiceClient

Dopo aver eseguito il deployment di Gemma 1B, utilizzi PredictionServiceClient per ottenere previsioni online per il prompt: "Perché il cielo è blu?"

Parametri di codice

Gli esempi di codice PredictionServiceClient richiedono di aggiornare quanto segue.

PROJECT_ID: Per trovare l'ID progetto, segui questi passaggi.
1. Vai alla pagina Benvenuto nella console Google Cloud .
  Vai a Benvenuto
2. Nel selettore di progetti nella parte superiore della pagina, seleziona il tuo progetto.
  
  Il nome, il numero e l'ID progetto vengono visualizzati dopo l'intestazione Benvenuto.
ENDPOINT_REGION: la regione in cui hai implementato l'endpoint.
ENDPOINT_ID: per trovare l'ID endpoint, visualizzalo nella console o esegui il comando gcloud ai endpoints list. Avrai bisogno del nome e della regione dell'endpoint dal riquadro Esegui il deployment del modello.
Console
Puoi visualizzare i dettagli dell'endpoint facendo clic su Online prediction > Endpoints e selezionando la tua regione. Prendi nota del numero visualizzato nella colonna ID.

Vai a Endpoint
gcloud
Puoi visualizzare i dettagli dell'endpoint eseguendo il comando gcloud ai endpoints list.
```
gcloud ai endpoints list \
  --region=ENDPOINT_REGION \
  --filter=display_name=ENDPOINT_NAME
```
L'output è simile al seguente.
```
Using endpoint [https://us-central1-aiplatform.googleapis.com/]
ENDPOINT_ID: 1234567891234567891
DISPLAY_NAME: gemma2-2b-it-mg-one-click-deploy
```

Codice di esempio

Nel codice campione per la tua lingua, aggiorna PROJECT_ID, ENDPOINT_REGION e ENDPOINT_ID. Poi esegui il codice.

Python

Per scoprire come installare o aggiornare l'SDK Vertex AI Python, consulta Installare l'SDK Vertex AI Python. Per saperne di più, consulta la documentazione di riferimento dell'API Python.

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

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

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

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

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

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

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

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

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

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di Vertex AI per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Vertex AI Node.js.

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di Vertex AI per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Vertex AI Java.

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale.


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

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida di Vertex AI per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Vertex AI Go.

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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
}

Esegui la pulizia

Per evitare che al tuo Account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina il progetto

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività descritte in questo documento, quando lo elimini, elimini anche tutto il lavoro che hai svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Elimina singole risorse

Se mantieni il progetto, elimina le risorse utilizzate in questo tutorial:

Annulla il deployment del modello ed elimina l'endpoint
Elimina il modello dal registro dei modelli

Annulla il deployment del modello ed elimina l'endpoint

Utilizza uno dei seguenti metodi per annullare il deployment di un modello ed eliminare l'endpoint.

Console

Nella console Google Cloud , fai clic su Previsione online, quindi su Endpoint.

Vai alla pagina Endpoint
Nell'elenco a discesa Regione, scegli la regione in cui hai eseguito il deployment dell'endpoint.
Fai clic sul nome dell'endpoint per aprire la pagina dei dettagli. Ad esempio gemma2-2b-it-mg-one-click-deploy.
Nella riga del modello Gemma 2 (Version 1), fai clic su Azioni, quindi su Annulla il deployment del modello nell'endpoint.
Nella finestra di dialogo Annulla il deployment del modello nell'endpoint, fai clic su Annulla il deployment.
Fai clic sul pulsante Indietro per tornare alla pagina Endpoint.

Vai alla pagina Endpoint
Alla fine della riga gemma2-2b-it-mg-one-click-deploy, fai clic su Azioni e poi seleziona Elimina endpoint.
Nel prompt di conferma, fai clic su Conferma.

gcloud

Per annullare il deployment del modello ed eliminare l'endpoint utilizzando Google Cloud CLI, segui questi passaggi.

In questi comandi, sostituisci:

PROJECT_ID con il nome del progetto
LOCATION_ID con la regione in cui hai eseguito il deployment del modello e dell'endpoint
ENDPOINT_ID con l'ID endpoint
DEPLOYED_MODEL_NAME con il nome visualizzato del modello
DEPLOYED_MODEL_ID con l'ID modello

Recupera l'ID endpoint eseguendo il comando gcloud ai endpoints list. Questo comando elenca gli ID endpoint per tutti gli endpoint del tuo progetto. Prendi nota dell'ID dell'endpoint utilizzato in questo tutorial.
```
gcloud ai endpoints list \
    --project=PROJECT_ID \
    --region=LOCATION_ID
```
L'output è simile al seguente. Nell'output, l'ID è chiamato ENDPOINT_ID.
```
Using endpoint [https://us-central1-aiplatform.googleapis.com/]
ENDPOINT_ID: 1234567891234567891
DISPLAY_NAME: gemma2-2b-it-mg-one-click-deploy
```

Recupera l'ID modello eseguendo il comando gcloud ai models describe. Prendi nota dell'ID del modello che hai implementato in questo tutorial.

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

L'output abbreviato è simile al seguente. Nell'output, l'ID è chiamato 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
...

Annulla il deployment del modello dall'endpoint. Avrai bisogno dell'ID endpoint e dell'ID modello dei comandi precedenti.

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

Questo comando non produce alcun output.

Esegui il comando gcloud ai endpoints delete per eliminare l'endpoint.
```
gcloud ai endpoints delete ENDPOINT_ID \
    --project=PROJECT_ID \
    --region=LOCATION_ID
```
Quando richiesto, digita y per confermare. Questo comando non produce alcun output.

Eliminare il modello

Console

Vai alla pagina Model Registry dalla sezione Vertex AI della console Google Cloud .

Vai alla pagina Model Registry
Nell'elenco a discesa Regione, scegli la regione in cui hai eseguito il deployment del modello.
Alla fine della riga gemma2-2b-it-1234567891234, fai clic su Azioni.
Seleziona Elimina modello.

Quando elimini il modello, tutte le versioni e le valutazioni associate vengono eliminate dal tuo progetto Google Cloud .
Nel prompt di conferma, fai clic su Elimina.

gcloud

Per eliminare il modello utilizzando Google Cloud CLI, fornisci il nome visualizzato e la regione del modello al comando gcloud ai models delete.

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

Sostituisci DEPLOYED_MODEL_NAME con il nome visualizzato del modello. Sostituisci PROJECT_ID con il nome del progetto. Sostituisci LOCATION_ID con la regione in cui hai eseguito il deployment del modello.

Passaggi successivi

Scopri di più sui modelli open di Gemma.
Leggi i Termini di servizio di Gemma.
Scopri di più sui modelli aperti.
Scopri come eseguire il deployment di un modello ottimizzato.
Scopri come eseguire il deployment di Gemma 2 su Google Kubernetes Engine utilizzando HuggingFace Textgen Inference (TGI).
Scopri di più su PredictionServiceClient nel tuo linguaggio preferito: Python, Node.js, Java o Go.

Esegui il deployment e l'inferenza di Gemma utilizzando gli endpoint basati su GPU di Model Garden e Vertex AI Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Obiettivi

Costi

Prima di iniziare

Configurare un progetto Google Cloud

Configura Google Cloud CLI

Configura l'SDK per il tuo linguaggio di programmazione

Python

Node.js

Java

Maven con BOM

Maven senza BOM

Gradle senza BOM

Vai

Esegui il deployment di Gemma utilizzando Model Garden

Python

gcloud

REST

Elenca i modelli di cui puoi eseguire il deployment

curl

PowerShell

Esegui il deployment di un modello

Esegui il deployment di un modello con la sua configurazione predefinita.

curl

PowerShell

Esegui il deployment di un modello Hugging Face

curl

PowerShell

Esegui il deployment di un modello con personalizzazioni

curl

PowerShell

Console

Terraform

Esegui il deployment di un modello

Applica la configurazione

Esegui la pulizia

Inferenza di Gemma 1B con PredictionServiceClient

Parametri di codice

Console

gcloud

Codice di esempio

Python

Node.js

Java

Go

Esegui la pulizia

Elimina il progetto

Elimina singole risorse

Annulla il deployment del modello ed elimina l'endpoint

Console

gcloud

Eliminare il modello

Console

gcloud

Passaggi successivi

Esegui il deployment e l'inferenza di Gemma utilizzando gli endpoint basati su GPU di Model Garden e Vertex AI