Gemma mit Model Garden und GPU-gestützten Vertex AI-Endpunkten bereitstellen und Inferenzen ausführen

In dieser Anleitung erfahren Sie, wie Sie das offene Modell Gemma 1B mithilfe von Model Garden auf einem GPU-gestützten Vertex AI-Endpunkt bereitstellen. Sie müssen ein Modell auf einem Endpunkt bereitstellen, bevor es für Onlinevorhersagen verwendet werden kann. Durch die Bereitstellung eines Modells werden dem Modell physische Ressourcen zugeordnet, sodass es Onlinevorhersagen mit niedriger Latenz bereitstellen kann.

Nachdem Sie das Gemma 1B-Modell bereitgestellt haben, können Sie das trainierte Modell mit dem PredictionServiceClient für Onlinevorhersagen verwenden. Onlinevorhersagen sind synchrone Anfragen an ein Modell, das auf einem Endpunkt bereitgestellt wird.

Ziele

In dieser Anleitung werden die folgenden Aufgaben erläutert:

  • Das offene Modell Gemma 1B mit Model Garden auf einem GPU-gestützten Endpunkt bereitstellen
  • PredictionServiceClient für Onlinevorhersagen verwenden

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen.

Neuen Google Cloud Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweise

Für dieses Tutorial müssen Sie Folgendes tun:

  • Ein Google Cloud Projekt einrichten und die Vertex AI API aktivieren
  • Auf Ihrem lokalen Computer:
    • Google Cloud CLI installieren, initialisieren und authentifizieren
    • SDK für Ihre Sprache installieren

Google Cloud -Projekt einrichten

Richten Sie Ihr Google Cloud -Projekt ein und aktivieren Sie die Vertex AI API.

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

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

    Roles required to select or create a project

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

    Go to project selector

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

  4. Enable the Vertex AI API.

    Roles required to enable APIs

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

    Enable the API

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

    Roles required to select or create a project

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

    Go to project selector

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

  7. Enable the Vertex AI API.

    Roles required to enable APIs

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

    Enable the API

    8.

    Google Cloud CLI einrichten

    Richten Sie die Google Cloud CLI auf Ihrem lokalen Computer ein.

    1. Installieren und initialisieren Sie Google Cloud CLI.

    2. Wenn Sie die gcloud CLI bereits installiert haben, aktualisieren Sie die gcloud-Komponenten mit diesem Befehl.

      gcloud components update

    3. Wenn Sie sich mit der gcloud CLI authentifizieren möchten, generieren Sie eine lokale Datei mit Standardanmeldedaten für Anwendungen (Application Default Credentials, ADC), indem Sie diesen Befehl ausführen. Der durch den Befehl gestartete Web-Flow wird verwendet, um Ihre Nutzeranmeldedaten anzugeben.

      gcloud auth application-default login

      Weitere Informationen finden Sie unter Authentifizierungskonfiguration der gcloud CLI und ADC-Konfiguration.

    SDK für Ihre Programmiersprache einrichten

    Um die in dieser Anleitung verwendete Umgebung einzurichten, installieren Sie das Vertex AI SDK für Ihre Sprache und die Protocol Buffers-Bibliothek. In den Codebeispielen werden Funktionen aus der Protocol Buffers-Bibliothek verwendet, um das Eingabeverzeichnis in das JSON-Format zu konvertieren, das von der API erwartet wird.

    Klicken Sie auf Ihrem lokalen Computer auf einen der folgenden Tabs, um das SDK für Ihre Programmiersprache zu installieren.

    Python

    Klicken Sie auf Ihrem lokalen Computer auf einen der folgenden Tabs, um das SDK für Ihre Programmiersprache zu installieren.

    • Installieren und aktualisieren Sie das Vertex AI SDK for Python, indem Sie diesen Befehl ausführen.

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

    • Installieren Sie die Protocol Buffers-Bibliothek für Python, indem Sie diesen Befehl ausführen.

      pip3 install --upgrade "protobuf>=5.28"

    Node.js

    Installieren oder aktualisieren Sie das aiplatform SDK für Node.js, indem Sie den folgenden Befehl ausführen.

    npm install @google-cloud/aiplatform

    Java

    Wenn Sie google-cloud-aiplatform als Abhängigkeit hinzufügen möchten, fügen Sie den entsprechenden Code für Ihre Umgebung hinzu.

    Maven mit BOM

    Fügen Sie Ihrem pom.xml folgenden HTML-Code hinzu:

    <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 ohne BOM

    Fügen Sie Folgendes zu pom.xml hinzu:

    <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 ohne BOM

    Fügen Sie zum build.gradle Folgendes hinzu:

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

    Go

    Installieren Sie diese Go-Pakete mit den folgenden Befehlen.

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

    Gemma mit Model Garden bereitstellen

    Sie können Gemma 1B mithilfe der Modellkarte in der Google Cloud Console oder programmatisch bereitstellen.

    Weitere Informationen zum Einrichten des Google Gen AI SDK oder der Google Cloud CLI finden Sie in der Übersicht über das Google Gen AI SDK oder unter Google Cloud CLI installieren.

    Python

    Informationen zur Installation des Vertex AI SDK for Python finden Sie unter Vertex AI SDK for Python installieren. Weitere Informationen finden Sie in der Python-API-Referenzdokumentation.

    1. Listen Sie die Modelle auf, die Sie bereitstellen können, und notieren Sie die Modell-ID, die Sie bereitstellen möchten. Optional können Sie die unterstützten Hugging Face-Modelle in Model Garden auflisten und sogar nach Modellnamen filtern. Die Ausgabe enthält keine abgestimmten Modelle.

      
import vertexai
from vertexai import model_garden

# TODO(developer): Update and un-comment below lines
# PROJECT_ID = "your-project-id"
vertexai.init(project=PROJECT_ID, location="us-central1")

# List deployable models, optionally list Hugging Face models only or filter by model name.
deployable_models = model_garden.list_deployable_models(list_hf_models=False, model_filter="gemma")
print(deployable_models)
# Example response:
# ['google/gemma2@gemma-2-27b','google/gemma2@gemma-2-27b-it', ...]

    2. Sehen Sie sich die Bereitstellungsspezifikationen für ein Modell mit der Modell-ID aus dem vorherigen Schritt an. Sie können den Maschinentyp, den Beschleunigertyp und den Container-Image-URI ansehen, die Model Garden für ein bestimmtes Modell überprüft hat.

      
import vertexai
from vertexai import model_garden

# TODO(developer): Update and un-comment below lines
# PROJECT_ID = "your-project-id"
# model = "google/gemma3@gemma-3-1b-it"
vertexai.init(project=PROJECT_ID, location="us-central1")

# For Hugging Face modelsm the format is the Hugging Face model name, as in
# "meta-llama/Llama-3.3-70B-Instruct".
# Go to https://console.cloud.google.com/vertex-ai/model-garden to find all deployable
# model names.

model = model_garden.OpenModel(model)
deploy_options = model.list_deploy_options()
print(deploy_options)
# Example response:
# [
#   dedicated_resources {
#     machine_spec {
#       machine_type: "g2-standard-12"
#       accelerator_type: NVIDIA_L4
#       accelerator_count: 1
#     }
#   }
#   container_spec {
#     ...
#   }
#   ...
# ]

    3. Stellen Sie ein Modell auf einem Endpunkt bereit. Im Model Garden wird die Standardkonfiguration für die Bereitstellung verwendet, sofern Sie keine zusätzlichen Argumente und Werte angeben.

      
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

    Bevor Sie beginnen, geben Sie ein Kontingentprojekt an, in dem die folgenden Befehle ausgeführt werden sollen. Die ausgeführten Befehle werden auf die Kontingente für dieses Projekt angerechnet. Weitere Informationen finden Sie unter Kontingentprojekt festlegen.

    1. Mit dem Befehl gcloud ai model-garden models list können Sie die Modelle auflisten, die Sie bereitstellen können. Mit diesem Befehl werden alle Modell-IDs und die Modelle aufgelistet, die Sie selbst bereitstellen können.

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

      Suchen Sie in der Ausgabe nach der Modell-ID, die Sie bereitstellen möchten. Das folgende Beispiel zeigt eine gekürzte Ausgabe.

      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

      Die Ausgabe enthält keine angepassten Modelle oder Hugging Face-Modelle. Wenn Sie sehen möchten, welche Hugging Face-Modelle unterstützt werden, fügen Sie das Flag --can-deploy-hugging-face-models hinzu.

    2. Führen Sie den Befehl gcloud ai model-garden models list-deployment-config aus, um die Bereitstellungsspezifikationen für ein Modell aufzurufen. Sie können den Maschinentyp, den Beschleunigertyp und den Container-Image-URI ansehen, die Model Garden für ein bestimmtes Modell unterstützt.

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

      Ersetzen Sie MODEL_ID durch die Modell-ID aus dem vorherigen Listenbefehl, z. B. google/gemma@gemma-2b oder stabilityai/stable-diffusion-xl-base-1.0.

    3. Stellen Sie ein Modell auf einem Endpunkt bereit, indem Sie den Befehl gcloud ai model-garden models deploy ausführen. Model Garden generiert einen Anzeigenamen für Ihren Endpunkt und verwendet die Standardbereitstellungskonfiguration, sofern Sie keine zusätzlichen Argumente und Werte angeben.

      Wenn Sie den Befehl asynchron ausführen möchten, fügen Sie das Flag --asynchronous ein.

      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]

      Ersetzen Sie die folgenden Platzhalter:

      • MODEL_ID: Die Modell-ID aus dem vorherigen Befehl zum Auflisten. Verwenden Sie für Hugging Face-Modelle das Hugging Face-Modell-URL-Format, z. B. stabilityai/stable-diffusion-xl-base-1.0.
      • MACHINE_TYPE: Definiert die Gruppe von Ressourcen, die für Ihr Modell bereitgestellt werden sollen, z. B. g2-standard-4.
      • ACCELERATOR_TYPE: Gibt Beschleuniger an, die Ihrer Bereitstellung hinzugefügt werden sollen, um die Leistung bei intensiven Arbeitslasten wie NVIDIA_L4 zu verbessern.
      • ENDPOINT_NAME: Ein Name für den bereitgestellten Vertex AI-Endpunkt.
      • HF_ACCESS_TOKEN: Geben Sie für Hugging Face-Modelle ein Zugriffstoken an, wenn das Modell eingeschränkt ist.
      • RESERVATION_RESOURCE_NAME: Wenn Sie eine bestimmte Compute Engine-Reservierung verwenden möchten, geben Sie den Namen der Reservierung an. Wenn Sie eine bestimmte Reservierung angeben, können Sie any-reservation nicht angeben.

      Die Ausgabe enthält die Bereitstellungskonfiguration, die von Model Garden verwendet wurde, die Endpunkt-ID und die Bereitstellungsvorgangs-ID, mit der Sie den Bereitstellungsstatus prüfen können.

      Using the default deployment configuration:
 Machine type: g2-standard-12
 Accelerator type: NVIDIA_L4
 Accelerator count: 1

The project has enough quota. The current usage of quota for accelerator type NVIDIA_L4 in region us-central1 is 0 out of 28.

Deploying the model to the endpoint. To check the deployment status, you can try one of the following methods:
1) Look for endpoint `ENDPOINT_DISPLAY_NAME` at the [Vertex AI] -> [Online prediction] tab in Cloud Console
2) Use `gcloud ai operations describe OPERATION_ID --region=LOCATION` to find the status of the deployment long-running operation

    4. Führen Sie den Befehl gcloud ai endpoints list --list-model-garden-endpoints-only aus, um Details zu Ihrem Deployment aufzurufen:

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

      Ersetzen Sie LOCATION_ID durch die Region, in der Sie das Modell bereitgestellt haben.

      Die Ausgabe enthält alle Endpunkte, die aus Model Garden erstellt wurden, sowie Informationen wie die Endpunkt-ID, den Endpunktnamen und ob der Endpunkt einem bereitgestellten Modell zugeordnet ist. Suchen Sie nach dem Endpunktnamen, der vom vorherigen Befehl zurückgegeben wurde, um Ihre Bereitstellung zu finden.

    REST

    Listen Sie alle bereitstellbaren Modelle auf und rufen Sie dann die ID des bereitzustellenden Modells ab. Anschließend können Sie das Modell mit der Standardkonfiguration und dem Standardendpunkt bereitstellen. Alternativ können Sie Ihr Deployment anpassen, z. B. einen bestimmten Maschinentyp festlegen oder einen dedizierten Endpunkt verwenden.

    Bereitstellbare Modelle auflisten

    Ersetzen Sie diese Werte in den folgenden Anfragedaten:

    • PROJECT_ID: Die Projekt-ID von Google Cloud
    • QUERY_PARAMETERS: Wenn Sie Model Garden-Modelle auflisten möchten, fügen Sie die folgenden Abfrageparameter listAllVersions=True&filter=is_deployable(true) hinzu. Wenn Sie Hugging Face-Modelle auflisten möchten, legen Sie den Filter auf alt=json&is_hf_wildcard(true)+AND+labels.VERIFIED_DEPLOYMENT_CONFIG%3DVERIFIED_DEPLOYMENT_SUCCEED&listAllVersions=True fest.

    HTTP-Methode und URL:

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

    Senden Sie die Anfrage mithilfe einer der folgenden Optionen:

    curl

    Führen Sie folgenden Befehl aus: 

    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

    Führen Sie folgenden Befehl aus: 

    $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

    Sie erhalten eine JSON-Antwort ähnlich der folgenden.

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

    Modell bereitstellen

    Stellen Sie ein Modell aus Model Garden oder ein Modell von Hugging Face bereit. Sie können die Bereitstellung auch anpassen, indem Sie zusätzliche JSON-Felder angeben.

    Modell mit der Standardkonfiguration bereitstellen

    Ersetzen Sie diese Werte in den folgenden Anfragedaten:

    • LOCATION: Eine Region, in der das Modell bereitgestellt wird.
    • PROJECT_ID: Die Projekt-ID von Google Cloud
    • MODEL_ID: Die ID des bereitzustellenden Modells. Sie können sie abrufen, indem Sie alle bereitstellbaren Modelle auflisten. Die ID hat das folgende Format: publishers/PUBLISHER_NAME/models/ MODEL_NAME@MODEL_VERSION.

    HTTP-Methode und URL:

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

    JSON-Text der Anfrage:

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

    Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

    curl

    Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json. Führen Sie folgenden Befehl im Terminal aus, um diese Datei im aktuellen Verzeichnis zu erstellen oder zu überschreiben: 

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

    Führen Sie dann folgenden Befehl aus, um Ihre REST-Anfrage zu senden: 

    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

    Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json. Führen Sie folgenden Befehl im Terminal aus, um diese Datei im aktuellen Verzeichnis zu erstellen oder zu überschreiben: 

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

    Führen Sie dann folgenden Befehl aus, um Ihre REST-Anfrage zu senden: 

    $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

    Sie erhalten eine JSON-Antwort ähnlich der folgenden.

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

    Hugging Face-Modell bereitstellen

    Ersetzen Sie diese Werte in den folgenden Anfragedaten:

    • LOCATION: Eine Region, in der das Modell bereitgestellt wird.
    • PROJECT_ID: Die Projekt-ID von Google Cloud
    • MODEL_ID: Die Hugging Face-Modell-ID des bereitzustellenden Modells. Sie können sie abrufen, indem Sie alle bereitstellbaren Modelle auflisten. Die ID hat das folgende Format: PUBLISHER_NAME/MODEL_NAME.
    • ACCESS_TOKEN: Wenn das Modell eingeschränkt ist, geben Sie ein Zugriffstoken an.

    HTTP-Methode und URL:

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

    JSON-Text der Anfrage:

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

    Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

    curl

    Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json. Führen Sie folgenden Befehl im Terminal aus, um diese Datei im aktuellen Verzeichnis zu erstellen oder zu überschreiben: 

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

    Führen Sie dann folgenden Befehl aus, um Ihre REST-Anfrage zu senden: 

    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

    Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json. Führen Sie folgenden Befehl im Terminal aus, um diese Datei im aktuellen Verzeichnis zu erstellen oder zu überschreiben: 

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

    Führen Sie dann folgenden Befehl aus, um Ihre REST-Anfrage zu senden: 

    $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

    Sie erhalten eine JSON-Antwort ähnlich der folgenden.

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

    Modell mit Anpassungen bereitstellen

    Ersetzen Sie diese Werte in den folgenden Anfragedaten:

    • LOCATION: Eine Region, in der das Modell bereitgestellt wird.
    • PROJECT_ID: Die Projekt-ID von Google Cloud
    • MODEL_ID: Die ID des bereitzustellenden Modells. Sie können sie abrufen, indem Sie alle bereitstellbaren Modelle auflisten. Die ID hat das folgende Format: publishers/PUBLISHER_NAME/models/ MODEL_NAME@MODEL_VERSION, z. B. google/gemma@gemma-2b oder stabilityai/stable-diffusion-xl-base-1.0.
    • MACHINE_TYPE: Definiert die Gruppe von Ressourcen, die für Ihr Modell bereitgestellt werden sollen, z. B. g2-standard-4.
    • ACCELERATOR_TYPE: Gibt Beschleuniger an, die Ihrem Deployment hinzugefügt werden sollen, um die Leistung bei intensiven Arbeitslasten wie NVIDIA_L4 zu verbessern.
    • ACCELERATOR_COUNT: Die Anzahl der Beschleuniger, die in Ihrem Deployment verwendet werden sollen.
    • reservation_affinity_type: Wenn Sie eine vorhandene Compute Engine-Reservierung für Ihre Bereitstellung verwenden möchten, geben Sie eine beliebige oder eine bestimmte Reservierung an. Wenn Sie diesen Wert angeben, geben Sie keinen Wert für spot an.
    • spot: Gibt an, ob Spot-VMs für die Bereitstellung verwendet werden sollen.
    • IMAGE_URI: Der Speicherort des zu verwendenden Container-Images, z. B. us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20241016_0916_RC00_maas
    • CONTAINER_ARGS: Argumente, die während des Deployments an den Container übergeben werden sollen.
    • CONTAINER_PORT: Eine Portnummer für Ihren Container.
    • fast_tryout_enabled: Wenn Sie ein Modell testen, können Sie eine schnellere Bereitstellung verwenden. Diese Option ist nur für die häufig verwendeten Modelle mit bestimmten Maschinentypen verfügbar. Wenn diese Option aktiviert ist, können Sie keine Modell- oder Bereitstellungskonfigurationen angeben.

    HTTP-Methode und URL:

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

    JSON-Text der Anfrage:

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

    Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

    curl

    Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json. Führen Sie folgenden Befehl im Terminal aus, um diese Datei im aktuellen Verzeichnis zu erstellen oder zu überschreiben: 

    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

    Führen Sie dann folgenden Befehl aus, um Ihre REST-Anfrage zu senden: 

    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

    Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json. Führen Sie folgenden Befehl im Terminal aus, um diese Datei im aktuellen Verzeichnis zu erstellen oder zu überschreiben: 

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

    Führen Sie dann folgenden Befehl aus, um Ihre REST-Anfrage zu senden: 

    $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

    Sie erhalten eine JSON-Antwort ähnlich der folgenden.

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

    Konsole

    1. Rufen Sie in der Google Cloud Console die Seite Model Garden auf.

      Zu Model Garden

    2. Suchen Sie ein unterstütztes Modell, das Sie bereitstellen möchten, und klicken Sie auf die zugehörige Modellkarte.

    3. Klicken Sie auf Bereitstellen, um den Bereich Modell bereitstellen zu öffnen.

    4. Geben Sie im Bereich Modell bereitstellen Details für die Bereitstellung an.

      1. Verwenden oder ändern Sie die generierten Modell- und Endpunktnamen.
      2. Wählen Sie einen Standort aus, an dem der Modellendpunkt erstellt werden soll.
      3. Wählen Sie einen Maschinentyp für jeden Knoten Ihrer Bereitstellung aus.

      4. Wenn Sie eine Compute Engine-Reservierung verwenden möchten, wählen Sie im Abschnitt Bereitstellungseinstellungen die Option Erweitert aus.

        Wählen Sie im Feld Reservierungstyp einen Reservierungstyp aus. Die Reservierung muss mit den von Ihnen angegebenen Maschinenspezifikationen übereinstimmen.

        • Erstellte Reservierung automatisch verwenden: Vertex AI wählt automatisch eine zulässige Reservierung mit übereinstimmenden Attributen aus. Wenn in der automatisch ausgewählten Reservierung keine Kapazität vorhanden ist, verwendet Vertex AI den allgemeinen Google Cloud-Ressourcenpool.
        • Spezifische Reservierungen auswählen: Vertex AI verwendet eine bestimmte Reservierung. Wenn für die ausgewählte Reservierung keine Kapazität vorhanden ist, wird ein Fehler ausgegeben.
        • Nicht verwenden (Standard): Vertex AI verwendet den allgemeinenGoogle Cloud -Ressourcenpool. Dieser Wert hat denselben Effekt wie das Weglassen einer Reservierung.

    5. Klicken Sie auf Bereitstellen.

    Terraform

    Informationen zum Anwenden oder Entfernen einer Terraform-Konfiguration finden Sie unter Grundlegende Terraform-Befehle. Weitere Informationen finden Sie in der Anbieterreferenzdokumentation zu Terraform.

    Modell bereitstellen

    Im folgenden Beispiel wird das Modell gemma-3-1b-it mit Standardkonfigurationen in us-central1 auf einem neuen Vertex AI-Endpunkt bereitgestellt.

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

    Informationen zum Bereitstellen eines Modells mit Anpassung finden Sie unter Vertex AI-Endpunkt mit Model Garden-Bereitstellung.

    Konfiguration anwenden

    terraform init
terraform plan
terraform apply

    Nachdem Sie die Konfiguration angewendet haben, stellt Terraform einen neuen Vertex AI-Endpunkt bereit und stellt das angegebene offene Modell bereit.

    Bereinigen

    Führen Sie den folgenden Befehl aus, um den Endpunkt und die Modellbereitstellung zu löschen:

    terraform destroy

    Gemma 1B mit dem PredictionServiceClient für die Inferenz verwenden

    Nachdem Sie Gemma 1B bereitgestellt haben, verwenden Sie PredictionServiceClient, um Onlinevorhersagen für den Prompt „Warum ist der Himmel blau?“ zu erhalten.

    Codeparameter

    Für die PredictionServiceClient-Codebeispiele müssen Sie Folgendes aktualisieren.

    • PROJECT_ID: So finden Sie Ihre Projekt-ID.

      1. Rufen Sie in der Google Cloud Console die Seite Willkommen auf.

        „Willkommen“ aufrufen

      2. Wählen Sie oben auf der Seite in der Projektauswahl Ihr Projekt aus.

        Der Projektname, die Projektnummer und die Projekt-ID werden nach der Überschrift Willkommen angezeigt.

    • ENDPOINT_REGION: Die Region, in der Sie den Endpunkt bereitgestellt haben.

    • ENDPOINT_ID: Die Endpunkt-ID finden Sie in der Konsole oder indem Sie den Befehl gcloud ai endpoints list ausführen. Sie benötigen den Endpunktnamen und die Region aus dem Bereich Modell bereitstellen.

      Konsole

      Sie können die Endpunktdetails aufrufen, indem Sie auf Onlinevorhersage > Endpunkte klicken und Ihre Region auswählen. Notieren Sie sich die Zahl, die in der Spalte ID angezeigt wird.

      Endpunkte aufrufen

      gcloud

      Mit dem Befehl gcloud ai endpoints list können Sie die Endpunktdetails aufrufen.

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

      Die Ausgabe sieht so aus:

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

    Beispielcode

    Aktualisieren Sie im Beispielcode für Ihre Sprache PROJECT_ID, ENDPOINT_REGION und ENDPOINT_ID. Führen Sie dann Ihren Code aus.

    Python

    Informationen zur Installation des Vertex AI SDK for Python finden Sie unter Vertex AI SDK for Python installieren. Weitere Informationen finden Sie in der Python-API-Referenzdokumentation. 

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

    Bevor Sie dieses Beispiel anwenden, folgen Sie den Node.js-Einrichtungsschritten in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI Node.js API.

    Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

    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

    Bevor Sie dieses Beispiel anwenden, folgen Sie den Java-Einrichtungsschritten in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI Java API.

    Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

    
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

    Bevor Sie dieses Beispiel anwenden, folgen Sie den Go-Einrichtungsschritten in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI Go API.

    Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

    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
}

    Bereinigen

    Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

    Projekt löschen

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

      Go to Manage resources

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

    Einzelne Ressourcen löschen

    Wenn Sie Ihr Projekt behalten möchten, löschen Sie die in dieser Anleitung verwendeten Ressourcen:

    • Bereitstellung des Modells aufheben und Endpunkt löschen
    • Modell aus Model Registry löschen

    Bereitstellung des Modells aufheben und Endpunkt löschen

    Verwenden Sie eine der folgenden Methoden, um die Bereitstellung eines Modells aufzuheben und den Endpunkt zu löschen:

    Console

    1. Klicken Sie in der Google Cloud -Konsole auf Onlinevorhersage und dann auf Endpunkte.

      Zur Seite „Endpunkte”

    2. Wählen Sie in der Drop-down-Liste Region die Region aus, in der Sie Ihren Endpunkt bereitgestellt haben.

    3. Klicken Sie auf den Endpunktnamen, um die Detailseite zu öffnen. Beispiel: gemma2-2b-it-mg-one-click-deploy.

    4. Klicken Sie in der Zeile für das Modell Gemma 2 (Version 1) auf Aktionen und dann auf Bereitstellung des Modells am Endpunkt aufheben.

    5. Klicken Sie im Dialogfeld Bereitstellung des Endpunkts aufheben auf Bereitstellung aufheben.

    6. Klicken Sie auf die Schaltfläche Zurück, um zur Seite Endpunkte zurückzukehren.

      Zur Seite „Endpunkte”

    7. Klicken Sie am Ende der Zeile für gemma2-2b-it-mg-one-click-deploy auf Aktionen und wählen Sie dann Endpunkt löschen aus.

    8. Klicken Sie in der Bestätigungsaufforderung auf Bestätigen.

    gcloud

    So heben Sie die Bereitstellung des Modells auf und löschen den Endpunkt mit der Google Cloud CLI:

    Ersetzen Sie in diesen Befehlen Folgendes:

    • PROJECT_ID durch Ihren Projektnamen.
    • LOCATION_ID durch die Region, in der Sie das Modell und den Endpunkt bereitgestellt haben.
    • ENDPOINT_ID durch die Endpunkt-ID
    • DEPLOYED_MODEL_NAME durch den Anzeigenamen des Modells
    • DEPLOYED_MODEL_ID durch die Modell-ID

    1. Rufen Sie die Endpunkt-ID mit dem Befehl gcloud ai endpoints list ab. Mit diesem Befehl werden die Endpunkt-IDs für alle Endpunkte in Ihrem Projekt aufgelistet. Notieren Sie sich die ID des Endpunkts, der in dieser Anleitung verwendet wird.

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

      Die Ausgabe sieht so aus: In der Ausgabe wird die ID als ENDPOINT_ID bezeichnet.

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

    2. Rufen Sie die Modell-ID mit dem Befehl gcloud ai models describe ab. Notieren Sie sich die ID des Modells, das Sie in dieser Anleitung bereitgestellt haben.

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

      Die gekürzte Ausgabe sieht so aus. In der Ausgabe wird die ID als deployedModelId bezeichnet.

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

    3. Heben Sie die Bereitstellung des Modells am Endpunkt auf. Sie benötigen die Endpunkt-ID und die Modell-ID aus den vorherigen Befehlen.

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

      Dieser Befehl erzeugt keine Ausgabe.

    4. Führen Sie den Befehl gcloud ai endpoints delete aus, um den Endpunkt zu löschen.

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

      Geben Sie bei Aufforderung zur Bestätigung y ein. Dieser Befehl erzeugt keine Ausgabe.

    Modell löschen

    Console

    1. Rufen Sie in der Google Cloud Console im Bereich „Vertex AI“ die Seite Model Registry auf.

      Zur Seite Model Registry

    2. Wählen Sie in der Drop-down-Liste Region die Region aus, in der Sie Ihr Modell bereitgestellt haben.

    3. Klicken Sie am Ende der Zeile für gemma2-2b-it-1234567891234 auf  Aktionen.

    4. Wählen Sie Modell löschen aus.

      Wenn Sie das Modell löschen, werden alle zugehörigen Modellversionen und ‑bewertungen aus Ihrem Google Cloud Projekt gelöscht.

    5. Klicken Sie in der Bestätigungsaufforderung auf Löschen.

    gcloud

    Wenn Sie das Modell mit der Google Cloud CLI löschen möchten, geben Sie den Anzeigenamen und die Region des Modells für den Befehl gcloud ai models delete an.

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

    Ersetzen Sie DEPLOYED_MODEL_NAME durch den Anzeigenamen des Modells. Ersetzen Sie PROJECT_ID durch Ihren Projektnamen. Ersetzen Sie LOCATION_ID durch die Region, in der Sie das Modell bereitgestellt haben.

    Nächste Schritte