Modell auf einem 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.

Damit das Modell bereitgestellt werden kann, muss es in der Vertex AI Model Registry sichtbar sein. Informationen zur Model Registry, einschließlich der Möglichkeit, Modellartefakte zu importieren oder direkt in der Model Registry zu erstellen, finden Sie unter Einführung in Vertex AI Model Registry.

Sie können mehrere Modelle auf einem Endpunkt oder dasselbe Modell auf mehreren Endpunkten bereitstellen. Weitere Informationen zu Optionen und Anwendungsfällen für die Bereitstellung von Modellen finden Sie unter Gründe für die Bereitstellung mehrerer Modelle für denselben Endpunkt.

Modell auf einem Endpunkt bereitstellen

Verwenden Sie eine der folgenden Methoden, um ein Modell bereitzustellen:

Google Cloud Console

  1. Rufen Sie in der Google Cloud Console im Abschnitt "Vertex AI" die Seite Modelle auf.

    Zur Seite "Modelle"

  2. Klicken Sie auf den Namen und die Versions-ID des Modells, das Sie bereitstellen möchten, um die Detailseite zu öffnen.

  3. Wählen Sie den Tab Deploy & Test (Bereitstellen und testen) aus.

    Wenn Ihr Modell bereits für Endpunkte bereitgestellt ist, werden diese im Abschnitt Modell bereitstellen aufgeführt.

  4. Klicken Sie auf In Endpunkt bereitstellen.

  5. Wählen Sie Neuen Endpunkt erstellen aus und geben Sie einen Namen für den neuen Endpunkt an, um Ihr Modell auf einem neuen Endpunkt bereitzustellen. Zum Bereitstellen des Modells auf einem vorhandenen Endpunkt wählen Sie Zu vorhandenem Endpunkt hinzufügen und anschließend den Endpunkt aus der Drop-down-Liste aus.

    Sie können mehrere Modelle auf einem Endpunkt oder dasselbe Modell auf mehreren Endpunkten bereitstellen.

  6. Wenn Sie das Modell auf einem vorhandenen Endpunkt bereitstellen, auf dem ein oder mehrere Modelle bereitgestellt werden, müssen Sie den Prozentsatz für die Trafficaufteilung für das bereitzustellende Modell und die bereits bereitgestellten Modelle aktualisieren, sodass alle Prozentwerte zusammengenommen 100 % ergeben.

  7. Wenn Sie Ihr Modell auf einem neuen Endpunkt bereitstellen, akzeptieren Sie für die Trafficaufteilung 100. Andernfalls passen Sie die Werte der Trafficaufteilung für alle Modelle auf dem Endpunkt an, sodass sie 100 ergeben.

  8. Geben Sie die Mindestanzahl von Computing-Knoten ein, die Sie für das Modell bereitstellen möchten.

    Dies ist die Anzahl der Knoten, die für das Modell jederzeit verfügbar sein müssen.

    Unabhängig davon, ob die Vorhersagelast oder ein Standby-Knoten verarbeitet wird, werden Ihnen die Kosten für die verwendeten Knoten in Rechnung gestellt – auch ohne Vorhersagetraffic. Weitere Informationen finden Sie auf der Seite "Preise".

    Die Anzahl der Computing-Knoten kann erhöht werden, wenn dies zur Verarbeitung des Vorhersagetraffics erforderlich ist. Sie übersteigt jedoch nie die maximale Knotenanzahl.

  9. Geben Sie für die Verwendung von Autoscaling die maximale Anzahl von Rechenknoten ein, auf die Vertex AI hochskaliert werden soll.

  10. Wählen Sie den Maschinentyp aus.

    Größere Maschinenressourcen erhöhen die Vorhersageleistung und erhöhen die Kosten. Vergleichen Sie die verfügbaren Maschinentypen.

  11. Wählen Sie einen Beschleunigertyp und eine Anzahl der Beschleuniger aus.

    Wenn Sie den Beschleuniger beim Importieren oder beim Erstellen des Modells aktiviert haben, wird diese Option angezeigt.

    Die Anzahl der Beschleuniger finden Sie in der GPU-Tabelle, die die gültige Anzahl von GPUs angibt, die Sie mit jedem Maschinentyp verwenden können. Die Anzahl der Beschleuniger bezieht sich auf die Anzahl der Beschleuniger pro Knoten, nicht auf die Gesamtzahl der Beschleuniger in Ihrer Bereitstellung.

  12. Wenn Sie ein benutzerdefiniertes Dienstkonto für die Bereitstellung verwenden möchten, wählen Sie im Drop-down-Menü Dienstkonto ein Dienstkonto aus.

  13. Standardeinstellungen für das Vorhersage-Logging ändern

  14. Klicken Sie für Ihr Modell auf Fertig. Wenn alle Prozentsätze für Trafficaufteilung korrekt sind, klicken Sie auf Weiter.

    Die Region, in der Ihr bereitgestelltes Modell angezeigt wird. Dies muss die Region sein, in der Sie Ihr Modell erstellt haben.

  15. Klicken Sie auf Deploy, um Ihr Modell auf dem Endpunkt bereitzustellen.

API

Wenn Sie ein Modell mit der Vertex AI API bereitstellen, führen Sie die folgenden Schritte aus:

  1. Create: Erstellen Sie bei Bedarf einen Endpunkt.
  2. Get Sie die Endpunkt-ID.
  3. Deploy: Stellen Sie das Modell am Endpunkt bereit.

Endpunkt erstellen

Wenn Sie ein Modell auf einem vorhandenen Endpunkt bereitstellen, können Sie diesen Schritt überspringen und mit Endpunkt-ID abrufen fortfahren. Wenn Sie die Vorabversion des dedizierten Endpunkts ausprobieren möchten, fahren Sie mit Dedizierten Endpunkt erstellen fort.

gcloud

Im folgenden Beispiel wir der Befehl gcloud ai endpoints create verwendet:

gcloud ai endpoints create \
  --region=LOCATION_ID \
  --display-name=ENDPOINT_NAME

Ersetzen Sie dabei Folgendes:

  • LOCATION_ID: Die Region, in der Sie Vertex AI verwenden.
  • ENDPOINT_NAME: Der Anzeigename für den Endpunkt.

Es kann einige Sekunden dauern, bis das Google Cloud CLI den Endpunkt erstellt.

REST

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • LOCATION_ID: Ihre Region.
  • PROJECT_ID: Ihre Projekt-ID.
  • ENDPOINT_NAME: Der Anzeigename für den Endpunkt.

HTTP-Methode und URL:

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints

JSON-Text anfordern:

{
  "display_name": "ENDPOINT_NAME"
}

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/endpoints/ENDPOINT_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.CreateEndpointOperationMetadata",
    "genericMetadata": {
      "createTime": "2020-11-05T17:45:42.812656Z",
      "updateTime": "2020-11-05T17:45:42.812656Z"
    }
  }
}
Sie können den Status des Vorgangs abfragen, bis in der Antwort "done": true angegeben wird.

Terraform

Im folgenden Beispiel wird die Terraform-Ressource google_vertex_ai_endpoint verwendet, um einen Endpunkt zu erstellen.

Informationen zum Anwenden oder Entfernen einer Terraform-Konfiguration finden Sie unter Grundlegende Terraform-Befehle.

# Endpoint name must be unique for the project
resource "random_id" "endpoint_id" {
  byte_length = 4
}

resource "google_vertex_ai_endpoint" "default" {
  name         = substr(random_id.endpoint_id.dec, 0, 10)
  display_name = "sample-endpoint"
  description  = "A sample Vertex AI endpoint"
  location     = "us-central1"
  labels = {
    label-one = "value-one"
  }
}

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.api.gax.longrunning.OperationFuture;
import com.google.cloud.aiplatform.v1.CreateEndpointOperationMetadata;
import com.google.cloud.aiplatform.v1.Endpoint;
import com.google.cloud.aiplatform.v1.EndpointServiceClient;
import com.google.cloud.aiplatform.v1.EndpointServiceSettings;
import com.google.cloud.aiplatform.v1.LocationName;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateEndpointSample {

  public static void main(String[] args)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String endpointDisplayName = "YOUR_ENDPOINT_DISPLAY_NAME";
    createEndpointSample(project, endpointDisplayName);
  }

  static void createEndpointSample(String project, String endpointDisplayName)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    EndpointServiceSettings endpointServiceSettings =
        EndpointServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (EndpointServiceClient endpointServiceClient =
        EndpointServiceClient.create(endpointServiceSettings)) {
      String location = "us-central1";
      LocationName locationName = LocationName.of(project, location);
      Endpoint endpoint = Endpoint.newBuilder().setDisplayName(endpointDisplayName).build();

      OperationFuture<Endpoint, CreateEndpointOperationMetadata> endpointFuture =
          endpointServiceClient.createEndpointAsync(locationName, endpoint);
      System.out.format("Operation name: %s\n", endpointFuture.getInitialFuture().get().getName());
      System.out.println("Waiting for operation to finish...");
      Endpoint endpointResponse = endpointFuture.get(300, TimeUnit.SECONDS);

      System.out.println("Create Endpoint Response");
      System.out.format("Name: %s\n", endpointResponse.getName());
      System.out.format("Display Name: %s\n", endpointResponse.getDisplayName());
      System.out.format("Description: %s\n", endpointResponse.getDescription());
      System.out.format("Labels: %s\n", endpointResponse.getLabelsMap());
      System.out.format("Create Time: %s\n", endpointResponse.getCreateTime());
      System.out.format("Update Time: %s\n", endpointResponse.getUpdateTime());
    }
  }
}

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. 

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */

// const endpointDisplayName = 'YOUR_ENDPOINT_DISPLAY_NAME';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

// Imports the Google Cloud Endpoint Service Client library
const {EndpointServiceClient} = require('@google-cloud/aiplatform');

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const endpointServiceClient = new EndpointServiceClient(clientOptions);

async function createEndpoint() {
  // Configure the parent resource
  const parent = `projects/${project}/locations/${location}`;
  const endpoint = {
    displayName: endpointDisplayName,
  };
  const request = {
    parent,
    endpoint,
  };

  // Get and print out a list of all the endpoints for this resource
  const [response] = await endpointServiceClient.createEndpoint(request);
  console.log(`Long running operation : ${response.name}`);

  // Wait for operation to complete
  await response.promise();
  const result = response.result;

  console.log('Create endpoint response');
  console.log(`\tName : ${result.name}`);
  console.log(`\tDisplay name : ${result.displayName}`);
  console.log(`\tDescription : ${result.description}`);
  console.log(`\tLabels : ${JSON.stringify(result.labels)}`);
  console.log(`\tCreate time : ${JSON.stringify(result.createTime)}`);
  console.log(`\tUpdate time : ${JSON.stringify(result.updateTime)}`);
}
createEndpoint();

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

def create_endpoint_sample(
    project: str,
    display_name: str,
    location: str,
):
    aiplatform.init(project=project, location=location)

    endpoint = aiplatform.Endpoint.create(
        display_name=display_name,
        project=project,
        location=location,
    )

    print(endpoint.display_name)
    print(endpoint.resource_name)
    return endpoint

Dedizierten Endpunkt erstellen

Wenn Sie ein Modell auf einem vorhandenen Endpunkt bereitstellen, können Sie diesen Schritt überspringen.

Ein dedizierter Endpunkt ist ein schnellerer, stabilerer Endpunkt mit Unterstützung für größere Nutzlastgrößen und längere Zeitüberschreitungen für Anfragen.

Wenn Sie in der Vorabversion einen speziellen Endpunkt verwenden möchten, müssen Sie ihn explizit aktivieren.

REST 

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

Ersetzen Sie dabei Folgendes:

  • ENDPOINT_NAME: Der Anzeigename für den Endpunkt.
  • LOCATION_ID: Die Region, in der Sie Vertex AI verwenden.
  • PROJECT_ID: Die Projekt-ID Ihres Google Cloud-Projekts.

Python 

endpoint = aiplatform.Endpoint.create(
  display_name="ENDPOINT_NAME",
  dedicated_endpoint_enabled=True,
)

Ersetzen Sie dabei Folgendes:

  • ENDPOINT_NAME: Der Anzeigename für den Endpunkt.

Endpunkt-ID abrufen

Sie benötigen die Endpunkt-ID, um das Modell bereitzustellen.

gcloud

Im folgenden Beispiel wir der Befehl gcloud ai endpoints list verwendet:

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

Ersetzen Sie dabei Folgendes:

  • LOCATION_ID: Die Region, in der Sie Vertex AI verwenden.
  • ENDPOINT_NAME: Der Anzeigename für den Endpunkt.

Notieren Sie sich die Zahl, die in der Spalte ENDPOINT_ID angezeigt wird. Verwenden Sie diese ID im folgenden Schritt.

REST

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • LOCATION_ID: Die Region, in der Sie Vertex AI verwenden.
  • PROJECT_ID: Ihre Projekt-ID.
  • ENDPOINT_NAME: Der Anzeigename für den Endpunkt.

HTTP-Methode und URL:

GET https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints?filter=display_name=ENDPOINT_NAME

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

{
  "endpoints": [
    {
      "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/endpoints/ENDPOINT_ID",
      "displayName": "ENDPOINT_NAME",
      "etag": "AMEw9yPz5pf4PwBHbRWOGh0PcAxUdjbdX2Jm3QO_amguy3DbZGP5Oi_YUKRywIE-BtLx",
      "createTime": "2020-04-17T18:31:11.585169Z",
      "updateTime": "2020-04-17T18:35:08.568959Z"
    }
  ]
}
Beachten Sie den ENDPOINT_ID.

Modell bereitstellen

Wählen Sie unten den Tab für Ihre Sprache oder Umgebung aus:

gcloud

In den folgenden Beispielen wird der Befehl gcloud ai endpoints deploy-model verwendet.

Im folgenden Beispiel wird ein Model in einem Endpoint bereitgestellt, ohne GPUs zu verwenden, um die Vorhersagebereitstellung zu beschleunigen, ohne den Traffic auf mehrere DeployedModel-Ressourcen aufzuteilen:

Ersetzen Sie folgende Werte, bevor sie einen der Befehlsdaten verwenden:

  • ENDPOINT_ID: Die ID des Endpunkts.
  • LOCATION_ID: Die Region, in der Sie Vertex AI verwenden.
  • MODEL_ID: Die ID des bereitzustellenden Modells.
  • DEPLOYED_MODEL_NAME: Ein Name für DeployedModel. Sie können auch den Anzeigenamen von Model für DeployedModel verwenden.
  • MIN_REPLICA_COUNT: Die minimale Anzahl von Knoten für diese Bereitstellung. Die Knotenzahl kann je nach der Vorhersagelast erhöht oder verringert werden, bis zur maximalen Anzahl von Knoten und niemals auf weniger als diese Anzahl von Knoten.
  • MAX_REPLICA_COUNT: Die maximale Anzahl von Knoten für diese Bereitstellung. Die Knotenzahl kann je nach der Vorhersagelast erhöht oder verringert werden, bis zu dieser Anzahl von Knoten und niemals auf weniger als die minimale Anzahl von Knoten. Wenn Sie das Flag --max-replica-count weglassen, wird die maximale Anzahl von Knoten auf den Wert von --min-replica-count festgelegt.

Führen Sie den Befehl gcloud ai endpoints deploy-model aus:

Linux, macOS oder Cloud Shell

gcloud ai endpoints deploy-model ENDPOINT_ID\
  --region=LOCATION_ID \
  --model=MODEL_ID \
  --display-name=DEPLOYED_MODEL_NAME \
  --min-replica-count=MIN_REPLICA_COUNT \
  --max-replica-count=MAX_REPLICA_COUNT \
  --traffic-split=0=100

Windows (PowerShell)

gcloud ai endpoints deploy-model ENDPOINT_ID`
  --region=LOCATION_ID `
  --model=MODEL_ID `
  --display-name=DEPLOYED_MODEL_NAME `
  --min-replica-count=MIN_REPLICA_COUNT `
  --max-replica-count=MAX_REPLICA_COUNT `
  --traffic-split=0=100

Windows (cmd.exe)

gcloud ai endpoints deploy-model ENDPOINT_ID^
  --region=LOCATION_ID ^
  --model=MODEL_ID ^
  --display-name=DEPLOYED_MODEL_NAME ^
  --min-replica-count=MIN_REPLICA_COUNT ^
  --max-replica-count=MAX_REPLICA_COUNT ^
  --traffic-split=0=100
  

Traffic aufteilen

Das Flag --traffic-split=0=100 in den vorherigen Beispielen sendet 100 % des Vorhersagetraffics, den der Endpoint empfängt, an das neue DeployedModel, das durch die temporäre ID 0 dargestellt wird. Wenn Ihr Endpoint bereits andere DeployedModel-Ressourcen hat, können Sie den Traffic zwischen dem neuen DeployedModel und den alten aufteilen. Um z. B. 20 % des Traffics an das neue DeployedModel und 80% an ein älteres zu senden, führen Sie den folgenden Befehl aus:

Ersetzen Sie folgende Werte, bevor sie einen der Befehlsdaten verwenden:

  • OLD_DEPLOYED_MODEL_ID: die ID des vorhandenen DeployedModel.

Führen Sie den Befehl gcloud ai endpoints deploy-model aus:

Linux, macOS oder Cloud Shell

gcloud ai endpoints deploy-model ENDPOINT_ID\
  --region=LOCATION_ID \
  --model=MODEL_ID \
  --display-name=DEPLOYED_MODEL_NAME \ 
  --min-replica-count=MIN_REPLICA_COUNT \
  --max-replica-count=MAX_REPLICA_COUNT \
  --traffic-split=0=20,OLD_DEPLOYED_MODEL_ID=80

Windows (PowerShell)

gcloud ai endpoints deploy-model ENDPOINT_ID`
  --region=LOCATION_ID `
  --model=MODEL_ID `
  --display-name=DEPLOYED_MODEL_NAME \ 
  --min-replica-count=MIN_REPLICA_COUNT `
  --max-replica-count=MAX_REPLICA_COUNT `
  --traffic-split=0=20,OLD_DEPLOYED_MODEL_ID=80

Windows (cmd.exe)

gcloud ai endpoints deploy-model ENDPOINT_ID^
  --region=LOCATION_ID ^
  --model=MODEL_ID ^
  --display-name=DEPLOYED_MODEL_NAME \ 
  --min-replica-count=MIN_REPLICA_COUNT ^
  --max-replica-count=MAX_REPLICA_COUNT ^
  --traffic-split=0=20,OLD_DEPLOYED_MODEL_ID=80
  

REST

Modell bereitstellen

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • LOCATION_ID: Die Region, in der Sie Vertex AI verwenden.
  • PROJECT_ID: Ihre Projekt-ID.
  • ENDPOINT_ID: Die ID des Endpunkts.
  • MODEL_ID: Die ID des bereitzustellenden Modells.
  • DEPLOYED_MODEL_NAME: Ein Name für DeployedModel. Sie können auch den Anzeigenamen von Model für DeployedModel verwenden.
  • MACHINE_TYPE: Optional. Die für jeden Knoten dieser Bereitstellung verwendeten Maschinenressourcen. Die Standardeinstellung ist n1-standard-2. Weitere Informationen zu Maschinentypen.
  • ACCELERATOR_TYPE: Der Typ des Beschleunigers, der an die Maschine angehängt werden soll. Optional, wenn ACCELERATOR_COUNT nicht angegeben oder null ist. Nicht empfohlen für AutoML-Modelle oder benutzerdefinierte Modelle, die keine GPU-Images verwenden. Weitere Informationen
  • ACCELERATOR_COUNT: Die Anzahl der Beschleuniger, die für jedes Replikat verwendet werden soll. Optional. Sollte für AutoML-Modelle oder benutzerdefiniert trainierte Modelle, die keine GPU-Images verwenden, null oder nicht angegeben sein.
  • MIN_REPLICA_COUNT: Die minimale Anzahl von Knoten für diese Bereitstellung. Die Knotenzahl kann je nach der Vorhersagelast erhöht oder verringert werden, bis zur maximalen Anzahl von Knoten und niemals auf weniger als diese Anzahl von Knoten. Dieser Wert muss größer oder gleich 1 sein.
  • MAX_REPLICA_COUNT: Die maximale Anzahl von Knoten für diese Bereitstellung. Die Knotenzahl kann je nach der Vorhersagelast erhöht oder verringert werden, bis zu dieser Anzahl von Knoten und niemals auf weniger als die minimale Anzahl von Knoten.
  • TRAFFIC_SPLIT_THIS_MODEL: Der Prozentsatz des Vorhersagetraffics an diesen Endpunkt, der an das Modell mit diesem Vorgang weitergeleitet werden soll. Die Standardeinstellung ist 100. Alle Traffic-Prozentsätze müssen zusammen 100 % ergeben. Weitere Informationen zu Traffic-Splits
  • DEPLOYED_MODEL_ID_N: Optional. Wenn andere Modelle für diesen Endpunkt bereitgestellt werden, müssen Sie die Prozentsätze der Trafficaufteilung aktualisieren, sodass alle Prozentsätze zusammen 100 % ergeben.
  • TRAFFIC_SPLIT_MODEL_N: Der Prozentwert der Trafficaufteilung für den bereitgestellten Modell-ID-Schlüssel.
  • PROJECT_NUMBER: Die automatisch generierte Projektnummer Ihres Projekts.

HTTP-Methode und URL:

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:deployModel

JSON-Text anfordern:

{
  "deployedModel": {
    "model": "projects/PROJECT/locations/us-central1/models/MODEL_ID",
    "displayName": "DEPLOYED_MODEL_NAME",
    "dedicatedResources": {
       "machineSpec": {
         "machineType": "MACHINE_TYPE",
         "acceleratorType": "ACCELERATOR_TYPE",
         "acceleratorCount": "ACCELERATOR_COUNT"
       },
       "minReplicaCount": MIN_REPLICA_COUNT,
       "maxReplicaCount": MAX_REPLICA_COUNT
     },
  },
  "trafficSplit": {
    "0": TRAFFIC_SPLIT_THIS_MODEL,
    "DEPLOYED_MODEL_ID_1": TRAFFIC_SPLIT_MODEL_1,
    "DEPLOYED_MODEL_ID_2": TRAFFIC_SPLIT_MODEL_2
  },
}

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/endpoints/ENDPOINT_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.DeployModelOperationMetadata",
    "genericMetadata": {
      "createTime": "2020-10-19T17:53:16.502088Z",
      "updateTime": "2020-10-19T17:53:16.502088Z"
    }
  }
}

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.api.gax.longrunning.OperationFuture;
import com.google.cloud.aiplatform.v1.DedicatedResources;
import com.google.cloud.aiplatform.v1.DeployModelOperationMetadata;
import com.google.cloud.aiplatform.v1.DeployModelResponse;
import com.google.cloud.aiplatform.v1.DeployedModel;
import com.google.cloud.aiplatform.v1.EndpointName;
import com.google.cloud.aiplatform.v1.EndpointServiceClient;
import com.google.cloud.aiplatform.v1.EndpointServiceSettings;
import com.google.cloud.aiplatform.v1.MachineSpec;
import com.google.cloud.aiplatform.v1.ModelName;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;

public class DeployModelCustomTrainedModelSample {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String endpointId = "ENDPOINT_ID";
    String modelName = "MODEL_NAME";
    String deployedModelDisplayName = "DEPLOYED_MODEL_DISPLAY_NAME";
    deployModelCustomTrainedModelSample(project, endpointId, modelName, deployedModelDisplayName);
  }

  static void deployModelCustomTrainedModelSample(
      String project, String endpointId, String model, String deployedModelDisplayName)
      throws IOException, ExecutionException, InterruptedException {
    EndpointServiceSettings settings =
        EndpointServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();
    String location = "us-central1";

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (EndpointServiceClient client = EndpointServiceClient.create(settings)) {
      MachineSpec machineSpec = MachineSpec.newBuilder().setMachineType("n1-standard-2").build();
      DedicatedResources dedicatedResources =
          DedicatedResources.newBuilder().setMinReplicaCount(1).setMachineSpec(machineSpec).build();

      String modelName = ModelName.of(project, location, model).toString();
      DeployedModel deployedModel =
          DeployedModel.newBuilder()
              .setModel(modelName)
              .setDisplayName(deployedModelDisplayName)
              // `dedicated_resources` must be used for non-AutoML models
              .setDedicatedResources(dedicatedResources)
              .build();
      // key '0' assigns traffic for the newly deployed model
      // Traffic percentage values must add up to 100
      // Leave dictionary empty if endpoint should not accept any traffic
      Map<String, Integer> trafficSplit = new HashMap<>();
      trafficSplit.put("0", 100);
      EndpointName endpoint = EndpointName.of(project, location, endpointId);
      OperationFuture<DeployModelResponse, DeployModelOperationMetadata> response =
          client.deployModelAsync(endpoint, deployedModel, trafficSplit);

      // You can use OperationFuture.getInitialFuture to get a future representing the initial
      // response to the request, which contains information while the operation is in progress.
      System.out.format("Operation name: %s\n", response.getInitialFuture().get().getName());

      // OperationFuture.get() will block until the operation is finished.
      DeployModelResponse deployModelResponse = response.get();
      System.out.format("deployModelResponse: %s\n", deployModelResponse);
    }
  }
}

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

def deploy_model_with_dedicated_resources_sample(
    project,
    location,
    model_name: str,
    machine_type: str,
    endpoint: Optional[aiplatform.Endpoint] = None,
    deployed_model_display_name: Optional[str] = None,
    traffic_percentage: Optional[int] = 0,
    traffic_split: Optional[Dict[str, int]] = None,
    min_replica_count: int = 1,
    max_replica_count: int = 1,
    accelerator_type: Optional[str] = None,
    accelerator_count: Optional[int] = None,
    explanation_metadata: Optional[explain.ExplanationMetadata] = None,
    explanation_parameters: Optional[explain.ExplanationParameters] = None,
    metadata: Optional[Sequence[Tuple[str, str]]] = (),
    sync: bool = True,
):
    """
    model_name: A fully-qualified model resource name or model ID.
          Example: "projects/123/locations/us-central1/models/456" or
          "456" when project and location are initialized or passed.
    """

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

    model = aiplatform.Model(model_name=model_name)

    # The explanation_metadata and explanation_parameters should only be
    # provided for a custom trained model and not an AutoML model.
    model.deploy(
        endpoint=endpoint,
        deployed_model_display_name=deployed_model_display_name,
        traffic_percentage=traffic_percentage,
        traffic_split=traffic_split,
        machine_type=machine_type,
        min_replica_count=min_replica_count,
        max_replica_count=max_replica_count,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        explanation_metadata=explanation_metadata,
        explanation_parameters=explanation_parameters,
        metadata=metadata,
        sync=sync,
    )

    model.wait()

    print(model.display_name)
    print(model.resource_name)
    return model

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. 

const automl = require('@google-cloud/automl');
const client = new automl.v1beta1.AutoMlClient();

/**
 * Demonstrates using the AutoML client to create a model.
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = '[PROJECT_ID]' e.g., "my-gcloud-project";
// const computeRegion = '[REGION_NAME]' e.g., "us-central1";
// const datasetId = '[DATASET_ID]' e.g., "TBL2246891593778855936";
// const tableId = '[TABLE_ID]' e.g., "1991013247762825216";
// const columnId = '[COLUMN_ID]' e.g., "773141392279994368";
// const modelName = '[MODEL_NAME]' e.g., "testModel";
// const trainBudget = '[TRAIN_BUDGET]' e.g., "1000",
// `Train budget in milli node hours`;

// A resource that represents Google Cloud Platform location.
const projectLocation = client.locationPath(projectId, computeRegion);

// Get the full path of the column.
const columnSpecId = client.columnSpecPath(
  projectId,
  computeRegion,
  datasetId,
  tableId,
  columnId
);

// Set target column to train the model.
const targetColumnSpec = {name: columnSpecId};

// Set tables model metadata.
const tablesModelMetadata = {
  targetColumnSpec: targetColumnSpec,
  trainBudgetMilliNodeHours: trainBudget,
};

// Set datasetId, model name and model metadata for the dataset.
const myModel = {
  datasetId: datasetId,
  displayName: modelName,
  tablesModelMetadata: tablesModelMetadata,
};

// Create a model with the model metadata in the region.
client
  .createModel({parent: projectLocation, model: myModel})
  .then(responses => {
    const initialApiResponse = responses[1];
    console.log(`Training operation name: ${initialApiResponse.name}`);
    console.log('Training started...');
  })
  .catch(err => {
    console.error(err);
  });

Standardeinstellungen für das Vorhersage-Logging ändern

Vorgangsstatus abrufen

Einige Anfragen starten lang andauernde Vorgänge, die viel Zeit in Anspruch nehmen. Diese Anfragen geben einen Vorgangsnamen zurück, mit dem Sie den Status des Vorgangs aufrufen oder den Vorgang abbrechen können. Vertex AI stellt Hilfsmethoden bereit, um Aufrufe für Vorgänge mit langer Laufzeit auszuführen. Weitere Informationen finden Sie unter Mit lang andauernden Vorgängen arbeiten.

Beschränkungen

  • Wenn Sie VPC Service Controls aktiviert haben, hat der Container Ihres bereitgestellten Modells keinen Zugriff auf das Internet.

Modellbereitstellung konfigurieren

Bei der Modellbereitstellung müssen Sie für die Ausführung der Onlinevorhersage für folgende Bereiche Festlegungen treffen:

Erstellte Ressource Einstellung bei der Ressourcenerstellung
Endpunkt Speicherort zur Ausführung von Vorhersagen
Modell Zu verwendender Container (ModelContainerSpec)
DeployedModel Maschinen für die Onlinevorhersage

Nach der ersten Erstellung des Modells oder Endpunkts können Sie die aufgeführten Einstellungen nicht mehr ändern. Sie können sie auch nicht in der Anfrage für eine Onlinevorhersage überschreiben. Wenn Sie diese Einstellungen ändern möchten, müssen Sie das Modell neu bereitstellen.

Was beim Bereitstellen eines Modells geschieht

Wenn Sie ein Modell für einen Endpunkt bereitstellen, verknüpfen Sie physische Ressourcen (Maschinen) mit diesem Modell, damit Onlinevorhersagen bereitgestellt werden können. Für Onlinevorhersagen gelten niedrige Latenzanforderungen. Durch die Bereitstellung von Ressourcen für das Modell im Voraus verringern Sie die Latenz.

Der Trainingstyp des Modells (AutoML oder benutzerdefiniert) und Daten (von AutoML) bestimmen die Art der physischen Ressourcen, die für das Modell verfügbar sind. Nach der Modellbereitstellung können Sie einige dieser Ressourcen mit mutate mutieren, ohne eine neue Bereitstellung erstellen zu müssen.

Die Endpunktressource stellt den Dienstendpunkt (URL) bereit, mit dem Sie die Vorhersage anfordern. Beispiel:

https://us-central1-aiplatform.googleapis.com/v1/projects/{project}/locations/{location}/endpoints/{endpoint}:predict

Gründe für die Bereitstellung mehrerer Modelle für denselben Endpunkt

Wenn Sie zwei Modelle für denselben Endpunkt bereitstellen, können Sie ein Modell schrittweise durch das andere ersetzen. Angenommen, Sie verwenden ein Modell und finden eine Möglichkeit, die Genauigkeit dieses Modells mit neuen Trainingsdaten zu erhöhen. Sie möchten die Anwendung jedoch nicht so aktualisieren, dass sie auf eine neue Endpunkt-URL verweist, und Sie möchten keine plötzlichen Änderungen in Ihrer Anwendung vornehmen. Sie können das neue Modell dem gleichen Endpunkt hinzufügen, einen kleinen Teil des Traffics bereitstellen und die Trafficaufteilung für das neue Modell schrittweise erhöhen, bis sie 100 % des Traffics bereitstellt.

Da die Ressourcen mit dem Modell und nicht mit dem Endpunkt verknüpft sind, können Sie Modelle desselben Typs auf demselben Endpunkt bereitstellen. Als Best Practice wird jedoch empfohlen, Modelle eines bestimmten Typs (z. B. AutoML-Tabellen, benutzerdefiniert trainiert) auf einem Endpunkt bereitzustellen. Diese Konfiguration ist einfacher zu verwalten.

Gründe, um ein Modell auf mehreren Endpunkten bereitzustellen

Vielleicht möchten Sie Ihre Modelle mit verschiedenen Ressourcen für verschiedene Anwendungsumgebungen wie Tests und Produktion bereitstellen. Möglicherweise möchten Sie auch unterschiedliche SLOs für Ihre Vorhersageanfragen unterstützen. Vielleicht hat eine Ihrer Anwendungen einen deutlich höheren Leistungsbedarf als die anderen. In diesem Fall könnten Sie das Modell an einem leistungsstärkeren Endpunkt mit mehr Maschinenressourcen bereitstellen. Zur Optimierung der Kosten können Sie das Modell auch für einen Endpunkt mit geringerer Leistung und mit weniger Maschinenressourcen bereitstellen.

Skalierungsverhalten

Wenn Sie ein Modell für die Onlinevorhersage als DeployedModel bereitstellen, können Sie Vorhersageknoten so konfigurieren, dass sie automatisch skaliert werden. Setzen Sie dazu dedicatedResources.maxReplicaCount auf einen höheren Wert als dedicatedResources.minReplicaCount.

Wenn Sie ein DeployedModel konfigurieren, müssen Sie dedicatedResources.minReplicaCount auf mindestens 1 festlegen. Mit anderen Worten können Sie das DeployedModel nicht so konfigurieren, dass es auf Vorhersageknoten skaliert wird, wenn es nicht verwendet wird.

Zielauslastung und -konfiguration

Wenn Sie ein Modell ohne dedizierte GPU-Ressourcen bereitstellen, skaliert Vertex AI automatisch die Anzahl der Replikate nach oben oder unten, sodass die CPU-Nutzung mit dem Standardwert von 60 % übereinstimmt.

Wenn Sie ein Modell mit dedizierten GPU-Ressourcen bereitstellen (wenn machineSpec.accelerator_count über 0 liegt), skaliert Vertex AI standardmäßig die Anzahl der Replikate nach oben oder unten, sodass die CPU- oder GPU-Nutzung, je nachdem, welcher Wert höher ist, mit dem Standardwert von 60 % übereinstimmt. Wenn Ihr Vorhersagedurchsatz also eine hohe GPU-Nutzung, aber keine hohe CPU-Auslastung verursacht, wird Vertex AI hochskaliert und die CPU-Auslastung ist sehr niedrig, was im Monitoring sichtbar ist. Wenn Ihr benutzerdefinierter Container dagegen die GPU nicht ausreichend nutzt, aber einen anderen Prozess hat, der die CPU-Auslastung auf über 60 % erhöht, wird Vertex AI hochskaliert, auch wenn dies möglicherweise nicht erforderlich ist, um Ziele für die Abfragen pro Sekunde und die Latenz zu erreichen.

Sie können den Standardschwellenmesswert und das Ziel durch Angabe von autoscalingMetricSpecs überschreiben. Wenn Ihre Bereitstellung so konfiguriert ist, dass sie nur anhand der CPU-Nutzung skaliert, wird sie auch bei hoher GPU-Nutzung nicht hochskaliert.

Ressourcennutzung verwalten

Sie können Ihren Endpunkt überwachen, um Messwerte wie CPU- und Beschleunigernutzung, die Anzahl der Anfragen, die Latenz sowie die aktuelle und die Zielanzahl der Replikate zu verfolgen. Diese Informationen können Ihnen helfen, die Ressourcennutzung und das Skalierungsverhalten Ihres Endpunkts zu verstehen.

Beachten Sie, dass jedes Replikat nur einen einzigen Container ausführt. Das bedeutet: Wenn ein Vorhersagecontainer die ausgewählte Rechenressource nicht vollständig nutzen kann, z. B. Single-Threaded-Code für eine Mehrkern-Maschine oder ein benutzerdefiniertes Modell, das einen anderen Dienst als Teil der Erstellung der Vorhersage aufruft, werden Ihre Knoten möglicherweise nicht hochskaliert.

Wenn Sie beispielsweise FastAPI oder einen Modellserver mit einer konfigurierbaren Anzahl von Workern oder Threads verwenden, kann es in vielen Fällen sein, dass bei Vorhandensein mehrerer Worker die Ressourcenauslastung erhöht wird, wodurch der Dienst die Anzahl der Replikate besser automatisch skalieren kann.

Wir empfehlen in der Regel, mit einem Worker oder Thread pro Kern zu beginnen. Wenn Sie feststellen, dass die CPU-Auslastung niedrig ist, insbesondere bei hoher Last, oder dass Ihr Modell aufgrund der niedrigen CPU-Auslastung nicht hochskaliert wird, erhöhen Sie die Anzahl der Worker. Wenn Sie andererseits feststellen, dass die Auslastung zu hoch ist und die Latenz unter Last höher als erwartet ist, verwenden Sie weniger Worker. Wenn Sie bereits nur einen einzigen Worker verwenden, versuchen Sie es mit einem kleineren Maschinentyp.

Skalierungsverhalten und Verzögerung

Vertex AI passt die Anzahl der Replikate alle 15 Sekunden mithilfe von Daten aus dem vorherigen 5-Minuten-Fenster an. Für jeden 15-Sekunden-Zyklus misst das System die Serverauslastung und generiert anhand der folgenden Formel eine Zielanzahl von Replikaten:

target # of replicas = Ceil(current # of replicas * (current utilization / target utilization))

Wenn Sie beispielsweise zwei Replikate haben, die zu 100 % ausgelastet sind, ist das Ziel 4:

4 = Ceil(3.33) = Ceil(2 * (100% / 60%))

Ein weiteres Beispiel: Wenn Sie derzeit 10 Replikate haben und die Auslastung auf 1 % sinkt, ist das Ziel 1:

1 = Ceil(.167) = Ceil(10 * (1% / 60%))

Am Ende jedes 15-Sekunden-Zyklus passt das System die Anzahl der Replikate an den höchsten Zielwert aus dem 5-Minuten-Fenster an. Beachten Sie, dass aufgrund der Auswahl des höchsten Zielwerts der Endpunkt nicht herunterskaliert wird, wenn in diesem 5-Minuten-Fenster ein Auslastungsausschlag auftritt, selbst wenn die Gesamtauslastung sehr niedrig ist. Wenn das System hingegen hochskaliert werden muss, erfolgt dies innerhalb von 15 Sekunden, da der höchste Zielwert anstelle des Durchschnitts ausgewählt wird.

Auch wenn Vertex AI die Anzahl der Replikate anpasst, dauert es einige Zeit, bis die Replikate gestartet oder heruntergefahren werden. Daher gibt es eine zusätzliche Verzögerung, bevor der Endpunkt an den Traffic angepasst wird. Die wichtigsten Faktoren, die zu dieser Zeit beitragen, sind:

  • Die Zeit für die Bereitstellung und den Start der Compute Engine-VMs
  • Die Zeit, um den Container aus der Registry herunterzuladen
  • Die Zeit, um das Modell aus dem Speicher zu laden

Am besten verstehen Sie das reale Skalierungsverhalten Ihres Modells dadurch, dass Sie einen Lasttest ausführen und die für Ihr Modell und Ihren Anwendungsfall relevanten Eigenschaften optimieren. Wenn das Autoscaling für Ihre Anwendung nicht schnell genug hochskaliert wird, stellen Sie genügend min_replicas bereit, um den erwarteten Baseline-Traffic zu verarbeiten.

Skalierungskonfiguration aktualisieren

Wenn Sie beim Bereitstellen des Modells DedicatedResources oder AutomaticResources angegeben haben, können Sie die Skalierungskonfiguration aktualisieren, ohne das Modell noch einmal bereitzustellen. Rufen Sie dazu mutateDeployedModel auf.

Beispiel: Mit folgender Anfrage werden max_replica und autoscaling_metric_specs aktualisiert und das Container-Logging deaktiviert.

{
  "deployedModel": {
    "id": "2464520679043629056",
    "dedicatedResources": {
      "maxReplicaCount": 9,
      "autoscalingMetricSpecs": [
        {
          "metricName": "aiplatform.googleapis.com/prediction/online/cpu/utilization",
          "target": 50
        }
      ]
    },
    "disableContainerLogging": true
  },
  "update_mask": {
    "paths": [
      "dedicated_resources.max_replica_count",
      "dedicated_resources.autoscaling_metric_specs",
      "disable_container_logging"
    ]
  }
}

Verwendungshinweise:

  • Sie können nicht den Maschinentyp ändern oder von DedicatedResources zu AutomaticResources oder umgekehrt wechseln. Die einzigen Skalierungskonfigurationsfelder, die Sie ändern können, sind min_replica, max_replica und AutoscalingMetricSpec (nur DedicatedResources).
  • Sie müssen jedes Feld, das Sie aktualisieren müssen, in updateMask auflisten. Nicht aufgeführte Felder werden ignoriert.
  • Das DeployedModel muss den Status DEPLOYED haben. Es kann höchstens einen aktiven Mutationsvorgang pro bereitgestelltem Modell geben.
  • Mit mutateDeployedModel können Sie auch das Container-Logging aktivieren oder deaktivieren. Weitere Informationen finden Sie unter Onlinevorhersage-Logging.

Bereitstellung eines Modells aufheben und den Endpunkt löschen

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

Google Cloud Console

  1. Heben Sie die Bereitstellung des Modells so auf:

    1. Rufen Sie in der Google Cloud Console im Abschnitt "Vertex AI" die Seite Endpunkte auf.

      Zur Seite „Endpunkte”

    2. Klicken Sie auf den Namen und die Versions-ID des Modells, dessen Bereitstellung Sie aufheben möchten, um die Detailseite zu öffnen.

    3. Klicken Sie in der Zeile für das Modell auf Aktionen und dann auf Bereitstellung des Modells am Endpunkt aufheben.

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

    5. Wenn Sie weitere Modelle löschen möchten, wiederholen Sie die vorherigen Schritte.

  2. Optional: So löschen Sie den Endpunkt für Onlinevorhersagen:

    1. Rufen Sie in der Google Cloud Console im Abschnitt Vertex AI die Seite Onlinevorhersage auf.

      Zur Onlinevorhersage

    2. Wählen Sie den Endpunkt aus.

    3. Klicken Sie zum Löschen des Endpunkts auf Aktionen und dann auf Endpunkt löschen.

gcloud

  1. Listen Sie die Endpunkt-IDs für alle Endpunkte in Ihrem Projekt auf:

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

    Ersetzen Sie PROJECT_ID durch den Projektnamen und LOCATION_ID durch die Region, in der Sie Vertex AI verwenden.

  2. Geben Sie die Modell-IDs für die Modelle an, die auf einem Endpunkt bereitgestellt sind:

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

    Ersetzen Sie ENDPOINT_ID durch die Endpunkt-ID.

  3. So heben Sie die Bereitstellung eines Modells am Endpunkt auf:

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

    Ersetzen Sie DEPLOYED_MODEL_ID durch die Modell-ID.

  4. Optional: Löschen Sie den Endpunkt für Onlinevorhersagen:

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

Nächste Schritte