esegui il deployment di un modello in un endpoint

Devi eseguire il deployment di un modello su un endpoint prima che il modello possa essere utilizzato le previsioni online. Il deployment di un modello associa le risorse fisiche in modo che possa fornire previsioni online con bassa latenza.

Per poter eseguire il deployment, il modello deve essere visibile in Vertex AI Model Registry. Per informazioni su Model Registry, incluse informazioni importare gli artefatti del modello o crearli direttamente Registry di Vertex, consulta Introduzione a Vertex AI Model Registry.

Puoi eseguire il deployment di più modelli su un endpoint oppure dello stesso modello più endpoint. Per ulteriori informazioni sulle opzioni e sui casi d'uso per sul deployment di modelli, consulta Motivi per eseguire il deployment di più modelli nello stesso endpoint.

esegui il deployment di un modello in un endpoint

Utilizza uno dei seguenti metodi per eseguire il deployment di un modello:

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

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

{
  "display_name": "ENDPOINT_NAME"
}

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints"

$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_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints" | Select-Object -Expand Content

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

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

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());
    }
  }
}

/**
 * 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();

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

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

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

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints?filter=display_name=ENDPOINT_NAME"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints?filter=display_name=ENDPOINT_NAME" | Select-Object -Expand Content

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

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

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

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

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

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

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

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

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

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:deployModel"

$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_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:deployModel" | Select-Object -Expand Content

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

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

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

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

Limitazioni

• Se hai abilitato Controlli di servizio VPC, il container del modello di cui hai eseguito il deployment non avranno accesso a internet.

Configura il deployment del modello

Durante il deployment del modello, prendi le seguenti importanti decisioni su come esegui la previsione online:

Non puoi aggiornare queste impostazioni elencate dopo la creazione iniziale dell'elemento modello o endpoint e non puoi eseguirne l'override nella richiesta di previsione online. Se devi modificare queste impostazioni, devi rieseguire il deployment del modello.

Cosa succede quando esegui il deployment di un modello

Quando esegui il deployment di un modello in un endpoint, devi associare fisica (macchina) le risorse con il modello, in modo che possa fornire previsioni online. Previsioni online hanno requisiti di bassa latenza. Fornire risorse al modello in anticipo riduce la latenza.

Il tipo di addestramento del modello (AutoML o personalizzato) e i dati (AutoML) determinano i tipi di risorse fisiche disponibili per il modello. Dopo il giorno puoi eseguire il deployment mutate alcuni senza creare un nuovo deployment.

La risorsa endpoint fornisce l'endpoint di servizio (URL) che utilizzi per richiedere la previsione. Ad esempio:

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

Motivi per eseguire il deployment di più modelli nello stesso endpoint

Il deployment di due modelli nello stesso endpoint consente di sostituirne gradualmente uno l'una dall'altra. Ad esempio, supponi di utilizzare un modello e di trovare un modo aumentare l'accuratezza del modello con nuovi dati di addestramento. Tuttavia, non aggiornare l'applicazione in modo che punti a un nuovo URL dell'endpoint e vuoi creare cambiamenti improvvisi nella tua applicazione. Puoi aggiungere il nuovo modello lo stesso endpoint, gestendo una piccola percentuale di traffico e aumentando gradualmente la suddivisione del traffico per il nuovo modello finché non gestisce il 100% del traffico.

Poiché le risorse sono associate al modello anziché all'endpoint, puoi eseguire il deployment di modelli di tipi diversi sullo stesso endpoint. Tuttavia, è quella di eseguire il deployment di modelli di un tipo specifico (ad esempio, dati tabulari AutoML, addestramento personalizzato) a un endpoint. Questa configurazione è più facile da gestire.

Motivi per eseguire il deployment di un modello su più di un endpoint

Potresti voler eseguire il deployment dei tuoi modelli con risorse diverse per ambienti applicativi, come test e produzione. Potresti anche voler e supportare SLO diversi per le richieste di previsione. Forse uno dei tuoi ha esigenze di prestazioni molto più elevate rispetto alle altre. In questo caso, puoi eseguire il deployment del modello su un endpoint con prestazioni più elevate Google Cloud. Per ottimizzare i costi, puoi anche eseguire il deployment del modello a prestazioni inferiori e più elevate con meno risorse macchina.

Comportamento di scalabilità

Quando esegui il deployment di un modello per la previsione online come DeployedModel, puoi configurare nodi di previsione per scalare automaticamente. A questo scopo, imposta dedicatedResources.maxReplicaCount a un maggiore di dedicatedResources.minReplicaCount.

Quando configuri un valore DeployedModel, devi impostare da dedicatedResources.minReplicaCount ad almeno 1. In altre parole, non puoi configurare DeployedModel in modo che scala fino a 0 nodi di previsione quando inutilizzati.

Utilizzo e configurazione target

Per impostazione predefinita, se esegui il deployment di un modello senza risorse GPU dedicate, Vertex AI fa automaticamente lo scale up o lo scale down del numero di repliche in modo che L'utilizzo della CPU corrisponde al valore target predefinito del 60%.

Per impostazione predefinita, se esegui il deployment di un modello con risorse GPU dedicate (se machineSpec.accelerator_count è maggiore di 0), Vertex AI scalerà automaticamente il numero di repliche o inferiore in modo che l'utilizzo di CPU o GPU, a seconda di quale sia il valore più alto, corrisponda al valore predefinito 60% del valore target. Di conseguenza, se la velocità effettiva di previsione causa un'elevata GPU ma non un utilizzo elevato della CPU, lo scale up di Vertex AI sarà molto ridotto e sarà visibile durante il monitoraggio. Al contrario, se il container personalizzato sta sottoutilizzando la GPU, ma ha un processo non correlato che aumentano l'utilizzo della CPU di oltre il 60%, Vertex AI farà lo scale up, nel caso in cui ciò non fosse stato necessario per raggiungere gli obiettivi di QPS e latenza.

Puoi eseguire l'override della metrica e del target della soglia predefinita specificando autoscalingMetricSpecs. Tieni presente che se il deployment è configurato per la scalabilità solo in base all'utilizzo della CPU, non farà lo scale up anche se l'utilizzo della GPU è elevato.

Gestisci l'utilizzo delle risorse

Puoi monitorare endpoint per monitorare metriche come utilizzo di CPU e Accelerator, numero di richieste, latenza e il numero di repliche attuale e di destinazione. Queste informazioni possono aiutarti a comprendere il comportamento di scalabilità e utilizzo delle risorse dell'endpoint.

Tieni presente che ogni replica esegue un solo container. Ciò significa che se un container di previsione non può utilizzare completamente la risorsa di computing selezionata, ad esempio come codice con un singolo thread per una macchina multi-core, o un modello personalizzato che chiama a un altro servizio nell'ambito della previsione, lo scale up dei nodi potrebbe non essere completato.

Ad esempio, se utilizzi FastAPI o qualsiasi server modello che ha un numero configurabile di worker o thread, ci sono molti casi avere più di un worker può aumentare l'utilizzo delle risorse, migliorando la possibilità per il servizio di scalare automaticamente il numero di repliche.

In genere consigliamo di iniziare con un worker o thread per core. Se l'utilizzo della CPU è basso, soprattutto con un carico elevato, oppure il modello fare lo scale up perché l'utilizzo della CPU è basso, per poi aumentare il numero worker. Se invece noti che l'utilizzo è troppo elevato e la tua le latenze aumentano più del previsto sotto carico, prova a utilizzare meno worker. Se utilizzi già un solo worker, prova a usare un tipo di macchina più piccolo.

Comportamento di scalabilità e ritardo

Vertex AI regola il numero di repliche ogni 15 secondi utilizzando i dati nella finestra di 5 minuti precedente. Per ogni ciclo di 15 secondi, il sistema misura dell'utilizzo del server e genera un numero target di repliche in base seguente formula:

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

Ad esempio, se due repliche vengono utilizzate al 100%, il target è 4:

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

In un altro esempio, se hai 10 repliche e l'utilizzo scende all'1%, il target è 1:

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

Alla fine di ogni ciclo di 15 secondi, il sistema regola il numero di repliche corrisponde al valore target più alto della finestra di 5 minuti precedente. Nota che poiché viene scelto il valore target più alto, lo fare lo scale down dell'endpoint non verrà eseguito si registra un picco di utilizzo durante questo periodo di 5 minuti, anche se nel complesso è molto basso. Se invece è necessario fare lo scale up del sistema, lo farà entro 15 secondi poiché viene scelto il valore target più alto anziché la media.

Tieni presente che anche dopo che Vertex AI regola il numero di repliche, l'avvio o la disattivazione delle repliche richiede tempo. Pertanto, c'è un'ulteriore prima che l'endpoint possa adattarsi al traffico. I fattori principali che contribuiscono a questo periodo includono quanto segue:

• il tempo necessario per eseguire il provisioning e avviare le VM di Compute Engine
• il tempo necessario per scaricare il container dal registry
• il tempo necessario per caricare il modello

Il modo migliore per comprendere il comportamento di scalabilità nel mondo reale del modello è eseguire un test di carico e ottimizzare le caratteristiche importanti per il tuo modello il tuo caso d'uso. Se il gestore della scalabilità automatica non fa lo scale up abbastanza rapidamente per esegui il provisioning di un numero sufficiente di min_replicas per gestire la base di riferimento prevista per via del traffico.

Aggiorna la configurazione di scalabilità

Se hai specificato DedicatedResources o AutomaticResources quando hai eseguito il deployment puoi aggiornare la configurazione di scalabilità senza eseguire nuovamente il deployment del modello chiamando mutateDeployedModel

Ad esempio, la seguente richiesta aggiorna max_replica, autoscaling_metric_specs e disabilita il logging del container.

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

Note sull'utilizzo:

• Non puoi cambiare il tipo di macchina o passare da DedicatedResources a AutomaticResources o viceversa. L'unica configurazione di scalabilità che puoi modificare sono: min_replica, max_replica e AutoscalingMetricSpec (solo DedicatedResources).
• Devi elencare tutti i campi da aggiornare in updateMask. Non elencato vengono ignorati.
• Il metodo DeployedModel deve essere nello stato DEPLOYED. Può esserci al massimo una mutazione attiva operativa per modello di cui è stato eseguito il deployment.
• mutateDeployedModel consente anche di abilitare o disabilitare il logging dei container. Per ulteriori informazioni per informazioni, consulta Previsione online il logging.

Passaggi successivi

• Scopri come ricevere una previsione online.
• Scopri di più sugli endpoint privati.