Modelle in Model Garden verwenden

Modelle mit Model Garden in derGoogle Cloud Console entdecken, testen, optimieren und bereitstellen. Sie können Model Garden-Modelle auch mit der Google Cloud CLI bereitstellen.

Test-Prompts senden

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

    Zu Model Garden

  2. Suchen Sie nach einem unterstützten Modell, das Sie testen möchten, und klicken Sie auf Details ansehen.

  3. Klicken Sie auf Eingabeaufforderung-Design öffnen.

    Sie werden zur Seite Eingabeaufforderungsdesign weitergeleitet.

  4. Geben Sie in das Feld Eingabeaufforderung die Eingabeaufforderung ein, die Sie testen möchten.

  5. Optional: Konfigurieren Sie die Modellparameter.

  6. Klicken Sie auf Senden.

Modell abstimmen

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

    Zu Model Garden

  2. Geben Sie in Modelle suchen den Namen Gemma 3 ein und klicken Sie dann auf die Lupe, um zu suchen.

  3. Klicken Sie auf der Modellkarte Gemma 3 auf Details ansehen.

  4. Klicken Sie auf Pipeline zur Feinabstimmung öffnen.

    Sie werden zur Seite „Agent Platform Pipelines“ weitergeleitet.

  5. Klicken Sie auf Ausführung erstellen, um die Feinabstimmung zu starten.

In einem Notebook anhören

Die Modellkarten für die meisten Open-Source-Foundation-Modelle und feinabstimmbaren Modelle unterstützen die Feinabstimmung in einem Notebook.

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

    Zu Model Garden

  2. Suchen Sie nach einem unterstützten Modell, das Sie optimieren möchten, und rufen Sie die zugehörige Modellkarte auf.

  3. Klicken Sie auf Notebook öffnen.

Offenes Modell bereitstellen

Sie können ein Modell mithilfe seiner 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 zum Google Gen AI SDK oder unter Google Cloud CLI installieren.

Console

  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 entsprechende 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 aus, der für jeden Knoten Ihrer Bereitstellung verwendet werden soll.
    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 den von Ihnen angegebenen Maschinenspezifikationen entsprechen.

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

  5. Klicken Sie auf Bereitstellen.

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 API-Referenzdokumentation zu Python.

  1. Listen Sie die Modelle auf, die Sie bereitstellen können, und notieren Sie sich die Modell-ID, die Sie bereitstellen möchten. Sie können die unterstützten Hugging Face-Modelle in Model Garden optional 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. Rufen Sie die Bereitstellungsspezifikationen für ein Modell mithilfe der Modell-ID aus dem vorherigen Schritt auf. Sie können den Maschinentyp, den Beschleunigertyp und den Container-Image-URI aufrufen, die Model Garden für ein bestimmtes Modell verifiziert 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. Modell auf einem Endpunkt bereitstellen Model Garden verwendet die Standardbereitstellungskonfiguration, 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?"}])

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 Ihre Bereitstellung anpassen, z. B. einen bestimmten Maschinentyp festlegen oder einen dedizierten Endpunkt verwenden.

1. Modelle auflisten, die Sie bereitstellen können

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

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

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 diesen 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 wie diese:

{
  "publisherModels": [
    {
      "name": "publishers/google/models/gemma3",
      "versionId": "gemma-3-1b-it",
      "openSourceCategory": "GOOGLE_OWNED_OSS_WITH_GOOGLE_CHECKPOINT",
      "supportedActions": {
        "openNotebook": {
          "references": {
            "us-central1": {
              "uri": "https://colab.research.google.com/github/GoogleCloudPlatform/vertex-ai-samples/blob/main/notebooks/community/model_garden/model_garden_gradio_streaming_chat_completions.ipynb"
            }
          },
          "resourceTitle": "Notebook",
          "resourceUseCase": "Chat Completion Playground",
          "resourceDescription": "Chat with deployed Gemma 2 endpoints via Gradio UI."
        },
        "deploy": {
          "modelDisplayName": "gemma-3-1b-it",
          "containerSpec": {
            "imageUri": "us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250312_0916_RC01",
            "args": [
              "python",
              "-m",
              "vllm.entrypoints.api_server",
              "--host=0.0.0.0",
              "--port=8080",
              "--model=gs://vertex-model-garden-restricted-us/gemma3/gemma-3-1b-it",
              "--tensor-parallel-size=1",
              "--swap-space=16",
              "--gpu-memory-utilization=0.95",
              "--disable-log-stats"
            ],
            "env": [
              {
                "name": "MODEL_ID",
                "value": "google/gemma-3-1b-it"
              },
              {
                "name": "DEPLOY_SOURCE",
                "value": "UI_NATIVE_MODEL"
              }
            ],
            "ports": [
              {
                "containerPort": 8080
              }
            ],
            "predictRoute": "/generate",
            "healthRoute": "/ping"
          },
          "dedicatedResources": {
            "machineSpec": {
              "machineType": "g2-standard-12",
              "acceleratorType": "NVIDIA_L4",
              "acceleratorCount": 1
            }
          },
          "publicArtifactUri": "gs://vertex-model-garden-restricted-us/gemma3/gemma3.tar.gz",
          "deployTaskName": "vLLM 128K context",
          "deployMetadata": {
            "sampleRequest": "{\n    \"instances\": [\n        {\n          \"@requestFormat\": \"chatCompletions\",\n          \"messages\": [\n              {\n                  \"role\": \"user\",\n                  \"content\": \"What is machine learning?\"\n              }\n          ],\n          \"max_tokens\": 100\n        }\n    ]\n}\n"
          }
        },
        ...

2. Modell bereitstellen

Modell aus Model Garden oder Hugging Face bereitstellen 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: Ihre Google Cloud Projekt-ID
  • MODEL_ID: Die ID des bereitzustellenden Modells, die Sie durch Auflisten aller bereitstellbaren Modelle abrufen können. 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 wie diese:

{
  "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: Ihre Google Cloud Projekt-ID
  • MODEL_ID: Die Hugging Face-Modell-ID des bereitzustellenden Modells, die Sie durch Auflisten aller bereitstellbaren Modelle abrufen können. Die ID hat das folgende Format: PUBLISHER_NAME/MODEL_NAME.
  • ACCESS_TOKEN: Wenn das Modell zugriffsbeschrä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 wie diese:

{
  "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: Ihre Google Cloud Projekt-ID
  • MODEL_ID: Die ID des bereitzustellenden Modells, die Sie durch Auflisten aller bereitstellbaren Modelle abrufen können. 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 Sie Ihrer Bereitstellung hinzufügen können, um die Leistung bei intensiven Arbeitslasten wie NVIDIA_L4 zu verbessern.
  • ACCELERATOR_COUNT: Die Anzahl der Beschleuniger, die in Ihrer Bereitstellung 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 nicht spot an.
  • spot: Gibt an, ob Spot-VMs für Ihre 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 der Bereitstellung an den Container übergeben werden sollen.
  • CONTAINER_PORT: Eine Portnummer für Ihren Container.
  • fast_tryout_enabled: Beim Testen eines Modells können Sie eine schnellere Bereitstellung auswählen. Diese Option ist nur für die am häufigsten 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 wie diese:

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

gcloud

Bevor Sie beginnen, geben Sie ein Kontingentprojekt an, um die folgenden Befehle auszuführen. Die von Ihnen ausgeführten Befehle werden auf die Kontingente für dieses Projekt angerechnet. Weitere Informationen finden Sie unter Kontingentprojekt festlegen.

  1. Listen Sie die Modelle auf, die Sie bereitstellen können, indem Sie den Befehl gcloud ai model-garden models list ausführen. Mit diesem Befehl werden alle Modell-IDs aufgelistet und angegeben, welche Sie selbst bereitstellen können.

    gcloud ai model-garden models list

    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 abgestimmten 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 aufrufen, 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 hinzu.

    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 Listenbefehl. 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 Sie Ihrer Bereitstellung hinzufügen können, um die Leistung bei intensiven Arbeitslasten wie NVIDIA_L4 zu verbessern.
    • ENDPOINT_NAME: Ein Name für den bereitgestellten Gemini Enterprise Agent Platform-Endpunkt.
    • HF_ACCESS_TOKEN: Wenn das Modell bei Hugging Face-Modellen eingeschränkt ist, geben Sie ein Zugriffstoken an.
    • 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 von Model Garden verwendete Bereitstellungskonfiguration, die Endpunkt-ID und die ID des Bereitstellungsvorgangs, 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 [Agent Platform] -> [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 Ihrer Bereitstellung 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 mit einem bereitgestellten Modell verknüpft ist. Suchen Sie nach dem Endpunktnamen, der vom vorherigen Befehl zurückgegeben wurde, um Ihre Bereitstellung zu finden.

Terraform

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

Modell bereitstellen

Im folgenden Beispiel wird das Modell gemma-3-1b-it mit Standardkonfigurationen auf einem neuen Agent Platform-Endpunkt in us-central1 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 Agent Platform-Endpunkt mit Model Garden-Bereitstellung.

Konfiguration anwenden

terraform init
terraform plan
terraform apply

Nachdem Sie die Konfiguration angewendet haben, stellt Terraform einen neuen Agent Platform-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

Partnermodell bereitstellen und Vorhersageanfragen stellen

Rufen Sie in der Google Cloud Console die Seite Model Garden auf und verwenden Sie den Filter Modellsammlungen, um die Partnermodelle zur Selbstbereitstellung aufzurufen. Wählen Sie ein Modell aus der Liste der Partnermodelle mit Selbstbereitstellung aus und kaufen Sie es, indem Sie auf Aktivieren klicken.

Sie müssen die Bereitstellung auf den vom Partner erforderlichen Maschinentypen vornehmen, wie im Abschnitt „Empfohlene Hardwarekonfiguration“ auf der Model Garden-Modellkarte beschrieben. Nach der Bereitstellung befinden sich die Ressourcen für die Modellbereitstellung in einem sicheren, von Google verwalteten Projekt.

Console

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

    Zu Model Garden

  2. Wenn Sie ein bestimmtes Modell suchen möchten, geben Sie den Namen in das Suchfeld von Model Garden ein.

  3. Wenn Sie alle Modelle sehen möchten, die Sie selbst bereitstellen können, wählen Sie im Filterbereich im Abschnitt Modellsammlungen die Option Partnermodelle mit Selbstbereitstellung aus. Die resultierende Liste enthält alle selbst bereitstellbaren Partnermodelle.

  4. Klicken Sie auf den Namen des Modells, das Sie bereitstellen möchten, um die Modellkarte zu öffnen.

  5. Klicken Sie auf Bereitstellungsoptionen.

  6. Konfigurieren Sie im Bereich Auf Agent Platform bereitstellen die Bereitstellung, z. B. den Standort und den Maschinentyp.

  7. Klicken Sie auf Bereitstellen.

Nach Abschluss der Bereitstellung können Sie Vorhersagen über das SDK oder die API anfordern. Weitere Anleitungen finden Sie im Abschnitt „Dokumentation“ auf der Modellkarte.

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 API-Referenzdokumentation zu Python.

Modellbereitstellung mit nur einem Klick

Sie können ein Partnermodell mit einem Klick selbst bereitstellen.

  1. Rufen Sie die Bereitstellungsspezifikationen für ein Modell mithilfe der Modell-ID aus dem vorherigen Schritt auf. Sie können den Maschinentyp, den Beschleunigertyp und den Container-Image-URI aufrufen, die Model Garden für ein bestimmtes Modell verifiziert hat.

    import vertexai
from vertexai import model_garden

vertexai.init(project=PROJECT_ID, location="us-central1")

model = model_garden.PartnerModel(model)
deploy_options = model.list_deploy_options()
print(deploy_options)

  2. Modell mit 1-Klick-Bereitstellung bereitstellen

    from vertexai import model_garden

# Deploy model
model = model_garden.PartnerModel(f"{PUBLISHER}/{MODEL}@{VERSION}")

endpoint = model.deploy(
    machine_type=MACHINE_TYPE,
    accelerator_type=ACCELERATOR_TYPE,
    accelerator_count=ACCELERATOR_COUNT,
    min_replica_count=1,
    max_replica_count=1,
)

Mehrstufige Bereitstellung

Sie können auch ein Partnermodell hochladen, einen Endpunkt erstellen und das Modell manuell bereitstellen.

Ersetzen Sie in Ihrem Code die folgenden Platzhalter:

  • LOCATION: Die Region, in der Sie das Modell und den Endpunkt bereitstellen möchten.
  • PROJECT_ID: Ihre Projekt-ID.
  • DISPLAY_NAME: Ein aussagekräftiger Name für die zugehörige Ressource.
  • PUBLISHER_NAME: Der Name des Partners, der das Modell zum Hochladen oder Bereitstellen bereitstellt.
  • PUBLISHER_MODEL_NAME: Der Name des hochzuladenden Modells.
  • MACHINE_TYPE: Definiert die Gruppe von Ressourcen, die für Ihr Modell bereitgestellt werden sollen, z. B. g2-standard-4. Sie müssen mit einer der vom Partner bereitgestellten Konfigurationen übereinstimmen.
  • ACCELERATOR_TYPE: Gibt Beschleuniger an, die Sie Ihrer Bereitstellung hinzufügen können, um die Leistung bei intensiven Arbeitslasten wie NVIDIA_L4 zu verbessern. Sie müssen mit einer der vom Partner bereitgestellten Konfigurationen übereinstimmen.
  • ACCELERATOR_COUNT: Die Anzahl der zu verwendenden Beschleuniger. Sie müssen eine der vom Partner bereitgestellten Konfigurationen verwenden.
  • REQUEST_PAYLOAD: Die Felder und Werte, die in Ihre Vorhersageanfrage aufgenommen werden sollen. Sehen Sie sich die Model Garden-Modellkarte des Partners an, um die verfügbaren Felder zu sehen.
from google.cloud import aiplatform

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

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

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

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

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

# Unary call for predictions
PAYLOAD = {
    REQUEST_PAYLOAD
}

request = json.dumps(PAYLOAD)

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

print(response)

# Streaming call for predictions
PAYLOAD = {
    REQUEST_PAYLOAD
}

request = json.dumps(PAYLOAD)

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

REST

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 Ihre Bereitstellung anpassen, z. B. einen bestimmten Maschinentyp festlegen oder einen dedizierten Endpunkt verwenden.

Ersetzen Sie in den Beispiel-curl-Befehlen die folgenden Platzhalter:

  • LOCATION: Die Region, in der Sie das Modell und den Endpunkt bereitstellen möchten.
  • PROJECT_ID: Ihre Projekt-ID.
  • DISPLAY_NAME: Ein aussagekräftiger Name für die zugehörige Ressource.
  • PUBLISHER_NAME: Der Name des Partners, der das Modell zum Hochladen oder Bereitstellen bereitstellt.
  • PUBLISHER_MODEL_NAME: Der Name des hochzuladenden Modells.
  • ENDPOINT_ID: Die ID des Endpunkts.
  • MACHINE_TYPE: Definiert die Gruppe von Ressourcen, die für Ihr Modell bereitgestellt werden sollen, z. B. g2-standard-4. Sie müssen mit einer der vom Partner bereitgestellten Konfigurationen übereinstimmen.
  • ACCELERATOR_TYPE: Gibt Beschleuniger an, die Sie Ihrer Bereitstellung hinzufügen können, um die Leistung bei intensiven Arbeitslasten wie NVIDIA_L4 zu verbessern. Sie müssen mit einer der vom Partner bereitgestellten Konfigurationen übereinstimmen.
  • ACCELERATOR_COUNT: Die Anzahl der zu verwendenden Beschleuniger. Sie müssen eine der vom Partner bereitgestellten Konfigurationen verwenden.
  • REQUEST_PAYLOAD: Die Felder und Werte, die in Ihre Vorhersageanfrage aufgenommen werden sollen. Sehen Sie sich die Model Garden-Modellkarte des Partners an, um die verfügbaren Felder zu sehen.

  1. Laden Sie ein Modell hoch, um es Ihrer Model Registry hinzuzufügen.

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

  2. Erstellen Sie einen Endpunkt.

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

  3. Stellen Sie das hochgeladene Modell auf dem Endpunkt bereit.

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

  4. Nachdem das Modell bereitgestellt wurde, können Sie einen unären oder Streaming-Aufruf für Vorhersagen ausführen. Sehen Sie sich die Model Garden-Modellkarte des Partners an, um zu erfahren, welche API-Methoden unterstützt werden.

    • Beispiel für einen unären Aufruf:
    curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/endpoints/ENDPOINT_ID:rawPredict \
-d 'REQUEST_PAYLOAD'
    • Beispiel für einen Streamingaufruf:
    curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/endpoints/ENDPOINT_ID:streamRawPredict \
-d 'REQUEST_PAYLOAD'

Modell auf einem privaten Endpunkt bereitstellen

Sie können Modelle aus Model Garden auf einem Private Service Connect-Endpunkt (PSC) bereitstellen, um eine sichere und private Verbindung zu Ihrem Modell herzustellen. Diese Einrichtung kann auch in einen internen und externen regionalen Application Load Balancer integriert werden, wenn sie mit einer PSC-Netzwerk-Endpunktgruppe bereitgestellt wird. Führen Sie die folgenden Schritte aus, um einen PSC-Endpunkt für Ihr Modell zu konfigurieren und eine private Konnektivität zu gewährleisten.

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

    Zu Model Garden

  2. Suchen Sie ein Modell, das Sie bereitstellen möchten, und klicken Sie auf die entsprechende Modellkarte.

  3. Klicken Sie auf Modell bereitstellen. Im Bereich Modell bereitstellen basieren die vordefinierten Bereitstellungseinstellungen auf einem öffentlichen dedizierten Endpunkt.

  4. Wählen Sie Einstellung bearbeiten aus, um weitere Bereitstellungsoptionen wie den privaten Zugriff zu aktivieren.

  5. Konfigurieren Sie die Bereitstellungseinstellungen.

    • Wählen Sie einen Standort aus, an dem der Modellendpunkt erstellt werden soll.
    • Übernehmen oder ändern Sie den generierten Modell- und Endpunktnamen.
    • Die Auswahl eines Maschinentyps für Ihre Bereitstellung ist optional, da die empfohlene Konfiguration bereits für Sie ausgewählt wurde.
    • Wählen Sie im Feld Reservierungstyp einen Reservierungstyp aus. Die Reservierung muss den von Ihnen angegebenen Maschinenspezifikationen entsprechen.
      • Erstellte Reservierung automatisch verwenden: Die Gemini Enterprise Agent Platform wählt eine verfügbare Reservierung mit übereinstimmenden Attributen aus. Wenn in der ausgewählten Reservierung keine Kapazität verfügbar ist, verwendet die Gemini Enterprise Agent Platform den allgemeinen Ressourcenpool von Google Cloud .
      • Spezifische Reservierungen auswählen: Die Gemini Enterprise Agent Platform verwendet eine bestimmte Reservierung. Wenn in der ausgewählten Reservierung keine Kapazität verfügbar ist, schlägt die Bereitstellung fehl.
      • Keine Reservierung (Standard): Die Gemini Enterprise Agent Platform verwendet den allgemeinenGoogle Cloud -Ressourcenpool.
    • Konfigurieren Sie Ihre Verfügbarkeitsrichtlinien.
      • Standard: Ideal für die meisten Arbeitslasten.
      • Spot: Ideal für fehlertolerante Arbeitslasten.
      • Flex-Start: Verwendet Dynamic Workload Scheduling (DWS), um Ressourcenzuweisungsanfragen zu verwalten und zu priorisieren

  6. Konfigurieren Sie den Endpunktzugriff für private Netzwerke.

    • Wählen Sie Privat (Private Service Connect) aus.
    • Wählen Sie Projekt-IDs aus. Wenn Sie Zugriff auf andere Projekte gewähren möchten, geben Sie hier die entsprechenden Projekt-IDs ein. Wenn Sie dieses Feld leer lassen, kann nur innerhalb des aktuellen Projekts auf den Endpunkt zugegriffen werden.

  7. Klicken Sie auf Bereitstellen.

  8. Wenn Sie sich Ihre Bereitstellung ansehen möchten, rufen Sie die Seite Model Garden auf und wählen Sie Meine Endpunkte und Modelle ansehen aus. Sie wird dann im Abschnitt Meine Endpunkte aufgeführt. Achten Sie darauf, dass Sie die richtige Region ausgewählt haben, damit Ihr Endpunkt sichtbar ist. Wählen Sie den Endpunkt aus. Der Status wird als Wird bereitgestellt angezeigt und ändert sich nach Abschluss in Bereit.

  9. Rufen Sie die Endpunkt-ID ab, öffnen Sie dann Cloud Shell und führen Sie die folgenden Schritte aus, um den URI des privaten Dienstanhangs abzurufen:

    gcloud ai endpoints describe ENDPOINT_ID --region=REGION  | grep -i serviceAttachment:

    Ein Beispiel dafür sehen Sie unten:

    user@cloudshell:$ gcloud ai endpoints describe 2124795225560842240 --region=europe-west4 | grep -i serviceAttachment:
Using endpoint [https://europe-west4-aiplatform.googleapis.com/]
    serviceAttachment: projects/o9457b320a852208e-tp/regions/europe-west4/serviceAttachments/gkedpm-52065579567eaf39bfe24f25f7981d

Nachdem Sie den Dienstanhang erhalten haben, haben Sie die folgenden Optionen, um auf das Modell zuzugreifen:

  • Stellen Sie einen PSC-Endpunkt in derselben VPC wie das gewährte Projekt bereit. Dieser Ansatz ermöglicht die Erreichbarkeit über Hybridnetzwerke und innerhalb desselben VPC. Beachten Sie, dass PSC-Endpunkte nicht über VPC-Peering erreichbar sind.
  • Stellen Sie eine PSC-NEG (Private Service Connect Network Endpoint Group) bereit. Dies ist in derselben VPC wie das zulässige Projekt möglich. So können Sie das Modell über einen internen oder externen Load Balancer bereitstellen, was mehrere Vorteile bietet:
    • Zugriff über VPC-Peering: Auf den Load Balancer kann über Peering-VPC-Netzwerke zugegriffen werden.
    • Sicherheitsfunktionen: Sie erhalten Unterstützung für Cloud Armor und Model Armor, um Ihren Endpunkt zu schützen.
    • Traffic-Verwaltung: Ermöglicht erweitertes Traffic-Routing, z. B. das Umschreiben von Hosts und Pfaden.
    • Zentraler Zugriff: Ein einzelner Application Load Balancer kann verwendet werden, um Traffic mithilfe von Pfadregeln an das Modell weiterzuleiten.

Endpunkt ansehen oder verwalten

Wenn Sie Ihren Endpunkt aufrufen und verwalten möchten, rufen Sie die Seite Onlinevorhersage der Agent Platform auf.

Zur Onlinevorhersage

Die Agent Platform listet alle Endpunkte in Ihrem Projekt für eine bestimmte Region auf. Klicken Sie auf einen Endpunkt, um Details wie die auf dem Endpunkt bereitgestellten Modelle aufzurufen.

Modellbereitstellung aufheben und Ressourcen löschen

Wenn Sie verhindern möchten, dass ein bereitgestelltes Modell Ressourcen in Ihrem Projekt verwendet, heben Sie die Bereitstellung des Modells von seinem Endpunkt auf. Sie müssen die Bereitstellung eines Modells aufheben, bevor Sie den Endpunkt und das Modell löschen können.

Modellbereitstellung rückgängig machen

Bereitstellung eines Modells am Endpunkt aufheben

Console

  1. Rufen Sie in der Google Cloud Console auf der Seite Onlinevorhersage den Tab Endpunkte auf.

    Endpunkte aufrufen

  2. Wählen Sie in der Drop-down-Liste Region die Region aus, in der sich Ihr Endpunkt befindet.

  3. Klicken Sie auf den Namen des Endpunkts, um die Detailseite zu öffnen.

  4. Klicken Sie in der Zeile für das Modell auf Aktionen und wählen Sie Bereitstellung des Modells am Endpunkt aufheben aus.

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

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 API-Referenzdokumentation zu Python.

Ersetzen Sie in Ihrem Code Folgendes:

  • PROJECT_ID durch Ihre Projekt-ID
  • LOCATION durch Ihre Region, z. B. „us-central1“
  • ENDPOINT_ID durch Ihre Endpunkt-ID
from google.cloud import aiplatform

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

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

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

gcloud

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
  • MODEL_ID durch die Modell-ID aus dem Befehl zum Auflisten von Modellen
  • DEPLOYED_MODEL_ID durch die ID des bereitgestellten Modells

  1. Suchen Sie die Endpunkt-ID, die mit Ihrer Bereitstellung verknüpft ist, indem Sie den Befehl gcloud ai endpoints list ausführen.

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

  2. Ermitteln Sie die Modell-ID, indem Sie den Befehl gcloud ai models list ausführen.

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

  3. Verwenden Sie die Modell-ID aus dem vorherigen Befehl, um die ID des bereitgestellten Modells abzurufen. Führen Sie dazu den Befehl gcloud ai models describe aus.

    gcloud ai models describe MODEL_ID \
    --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
...

  4. Führen Sie den Befehl gcloud ai endpoints undeploy-model aus, um die Bereitstellung des Modells am Endpunkt aufzuheben. Verwenden Sie dazu die Endpunkt-ID und die ID des bereitgestellten Modells 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.

Endpunkte löschen

Löschen Sie den Gemini Enterprise Agent Platform-Endpunkt, der mit Ihrer Modellbereitstellung verknüpft war.

Console

  1. Rufen Sie in der Google Cloud Console auf der Seite Onlinevorhersage den Tab Endpunkte auf.

    Endpunkte aufrufen

  2. Wählen Sie in der Drop-down-Liste Region die Region aus, in der sich Ihr Endpunkt befindet.

  3. Klicken Sie am Ende der Zeile des Endpunkts auf Aktionen und wählen Sie dann Endpunkt löschen aus.

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

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 API-Referenzdokumentation zu Python.

Ersetzen Sie in Ihrem Code Folgendes:

  • PROJECT_ID durch Ihre Projekt-ID
  • LOCATION durch Ihre Region, z. B. „us-central1“
  • ENDPOINT_ID durch Ihre Endpunkt-ID
from google.cloud import aiplatform

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

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

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

gcloud

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

  1. Rufen Sie die zu löschende 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.

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

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

Modelle löschen

Löschen Sie die Modellressource, die mit Ihrer Modellbereitstellung verknüpft war.

Console

  1. Rufen Sie in der Google Cloud Console im Bereich „Agent Platform“ 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 in der Zeile für Ihr Modell auf Aktionen und wählen Sie dann Modell löschen aus.

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

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

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 API-Referenzdokumentation zu Python.

Ersetzen Sie in Ihrem Code Folgendes:

  • PROJECT_ID durch Ihre Projekt-ID
  • LOCATION durch Ihre Region, z. B. „us-central1“
  • MODEL_ID durch Ihre Modell-ID
from google.cloud import aiplatform

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

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

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

gcloud

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
  • MODEL_ID durch die Modell-ID aus dem Befehl zum Auflisten von Modellen.

  1. Suchen Sie die zu löschende Modell-ID mit dem Befehl gcloud ai models list.

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

  2. Führen Sie den Befehl gcloud ai models delete aus, um das Modell zu löschen. Geben Sie dazu die Modell-ID und den Speicherort des Modells an.

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

Codebeispiele ansehen

Die meisten Modellkarten für aufgabenspezifische Lösungsmodelle enthalten Codebeispiele, die Sie kopieren und testen können.

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

    Zu Model Garden

  2. Suchen Sie nach einem unterstützten Modell, für das Sie Codebeispiele aufrufen möchten, und klicken Sie auf den Tab Dokumentation.

  3. Auf der Seite wird zum Abschnitt „Dokumentation“ mit eingebettetem Beispielcode gescrollt.

Vision-App erstellen

Die Modellkarten für anwendbare Modelle für Computer Vision unterstützen die Erstellung einer Vision-Anwendung.

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

    Zu Model Garden

  2. Suchen Sie im Abschnitt „Aufgabenspezifische Lösungen“ nach einem Vision-Modell, das Sie zum Erstellen einer Vision-Anwendung verwenden möchten, und klicken Sie auf Details ansehen.

  3. Klicken Sie auf App erstellen.

    Sie werden zu Vertex AI Vision weitergeleitet.

  4. Geben Sie unter Anwendungsname einen Namen für Ihre Anwendung ein und klicken Sie auf Weiter.

  5. Wählen Sie einen Abrechnungstarif aus und klicken Sie auf Erstellen.

    Sie werden zu Vertex AI Vision Studio weitergeleitet, wo Sie die Anwendung für Computer Vision weiter erstellen können.