Eseguire il deployment di un modello in un endpoint

Devi eseguire il deployment di un modello in un endpoint prima di poterlo usare per fornire predizioni online. Il deployment di un modello associa risorse fisiche al modello in modo che possa fornire previsioni online con bassa latenza.

Per essere dispiegabile, il modello deve essere visibile in Vertex AI Model Registry. Per informazioni su Model Registry, inclusa la procedura per importare gli elementi del modello o crearli direttamente in Model Registry, consulta Introduzione a Vertex AI Model Registry.

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

Eseguire il deployment di un modello in un endpoint

Per eseguire il deployment di un modello, utilizza uno dei seguenti metodi:

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

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

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

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 attivato i Controlli di servizio VPC, il contenitore del modello di cui è stato eseguito il deployment non avrà accesso a internet.

Configura il deployment del modello

Durante il deployment del modello, devi prendere le seguenti decisioni importanti su come eseguire la previsione online:

Non puoi aggiornare queste impostazioni elencate dopo la creazione iniziale del modello o dell'endpoint e non puoi sostituirle nella richiesta di previsione online. Se devi modificare queste impostazioni, devi eseguire nuovamente il deployment del modello.

Cosa succede quando esegui il deployment di un modello

Quando esegui il deployment di un modello in un endpoint, associ risorse fisiche (macchine) al modello in modo che possa fornire previsioni online. Le previsioni online hanno requisiti di bassa latenza. Fornire le risorse al modello in anticipo riduce la latenza.

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

La risorsa endpoint fornisce l'endpoint (URL) del servizio 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 ti consente di sostituire gradualmente un modello con l'altro. Ad esempio, supponiamo che tu stia utilizzando un modello e trovi un modo per aumentarne l'accuratezza con nuovi dati di addestramento. Tuttavia, non vuoi aggiornare l'applicazione in modo che rimandi a un nuovo URL endpoint e non vuoi creare modifiche improvvise nell'applicazione. Puoi aggiungere il nuovo modello allo stesso endpoint, pubblicando una piccola percentuale di traffico, e aumentare gradualmente la suddivisione del traffico per il nuovo modello fino a quando 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 nello stesso endpoint. Tuttavia, la migliore prassi è eseguire il deployment di modelli di un tipo specifico (ad esempio tabulari AutoML, con addestramento personalizzato) in un endpoint. Questa configurazione è più facile da gestire.

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

Potresti voler eseguire il deployment dei modelli con risorse diverse per ambienti di applicazione diversi, ad esempio di test e di produzione. Potresti anche supportare SLO diversi per le richieste di previsione. È possibile che una delle tue applicazioni abbia esigenze di prestazioni molto più elevate rispetto alle altre. In questo caso, puoi eseguire il deployment del modello in un endpoint con prestazioni superiori e con più risorse di calcolo. Per ottimizzare i costi, puoi anche eseguire il deployment del modello in un endpoint con prestazioni inferiori e con meno risorse di sistema.

Comportamento di scalabilità

Quando esegui il deployment di un modello per la previsione online come DeployedModel, puoi configurare i nodi di previsione in modo che si scalino automaticamente. Per farlo, imposta dedicatedResources.maxReplicaCount su un valore maggiore di dedicatedResources.minReplicaCount.

Quando configuri un DeployedModel, devi impostare dedicatedResources.minReplicaCount su almeno 1. In altre parole, non puoi configurare DeployedModel per scalare fino a 0 nodi di previsione quando non è utilizzato.

Utilizzo e configurazione del target

Per impostazione predefinita, se esegui il deployment di un modello senza risorse GPU dedicate, Vertex AI aumenta o diminuisce automaticamente il numero di repliche in modo che l'utilizzo della CPU corrisponda 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 aumenterà o diminuirà automaticamente il numero di repliche in modo che l'utilizzo della CPU o della GPU, a seconda del valore più elevato, corrisponda al valore predefinito del 60%. Pertanto, se il throughput di previsione causa un utilizzo elevato della GPU, ma non della CPU, Vertex AI eseguirà il ridimensionamento e l'utilizzo della CPU sarà molto basso, il che sarà visibile nel monitoraggio. Al contrario, se il contenitore personalizzato sottoutilizza la GPU, ma ha un processo non correlato che aumenta l'utilizzo della CPU oltre il 60%, Vertex AI eseguirà l'upgrade, anche se potrebbe non essere stato necessario per raggiungere i target di QPS e latenza.

Puoi ignorare la metrica e il target della soglia predefiniti specificando autoscalingMetricSpecs. Tieni presente che se il deployment è configurato per il ridimensionamento in base solo all'utilizzo della CPU, non verrà eseguito lo scale up anche se l'utilizzo della GPU è elevato.

Gestire l'utilizzo delle risorse

Puoi monitorare il tuo endpoint per tenere traccia di metriche come l'utilizzo della CPU e dell'acceleratore, il numero di richieste, la latenza e il numero di repliche correnti e target. Queste informazioni possono aiutarti a comprendere il comportamento di scalabilità e l'utilizzo delle risorse del tuo endpoint.

Tieni presente che ogni replica esegue un solo contenitore. Ciò significa che se un contenitore di previsione non può utilizzare completamente la risorsa di calcolo selezionata, ad esempio codice a thread singolo per una macchina multi-core o un modello personalizzato che chiama un altro servizio durante la generazione della previsione, i nodi potrebbero non aumentare di dimensioni.

Ad esempio, se utilizzi FastAPI o qualsiasi server di modelli con un numero configurabile di worker o thread, in molti casi avere più di un worker può aumentare l'utilizzo delle risorse, migliorando la capacità del servizio di scalare automaticamente il numero di repliche.

In genere, consigliamo di iniziare con un worker o un thread per core. Se noti che l'utilizzo della CPU è basso, in particolare in caso di carico elevato, o se il tuo modello non viene eseguito in modalità di scalabilità perché l'utilizzo della CPU è basso, aumenta il numero di worker. Se invece noti che l'utilizzo è troppo elevato e le latenze aumentano più del previsto sotto carico, prova a utilizzare meno worker. Se utilizzi già un solo worker, prova a utilizzare un tipo di macchina più piccolo.

Comportamento di scalabilità e tempo di latenza

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

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

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

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

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

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

Al termine di ogni ciclo di 15 secondi, il sistema regola il numero di repliche in modo da corrispondere al valore target più alto della finestra dei 5 minuti precedenti. Tieni presente che, poiché viene scelto il valore target più alto, l'endpoint fare lo scale down se si verifica un picco di utilizzo durante la finestra di 5 minuti, anche se l'utilizzo complessivo è molto basso. D'altra parte, se il sistema deve essere scalato, lo farà entro 15 secondi poiché viene scelto il valore target più alto anziché la media.

Tieni presente che anche dopo che Vertex AI ha modificato il numero di repliche, è necessario del tempo per avviarle o ridurle. Di conseguenza, si verifica un ulteriore ritardo prima che l'endpoint possa adeguarsi al traffico. I fattori principali che contribuiscono a questo tempo includono:

• il tempo necessario per il provisioning e l'avvio delle VM Compute Engine
• il tempo per scaricare il contenitore dal registry
• il tempo necessario per caricare il modello dallo spazio di archiviazione

Il modo migliore per comprendere il comportamento di scalabilità del modello nel mondo reale è eseguire un test di carico e ottimizzare le caratteristiche importanti per il modello e il caso d'uso. Se lo strumento di scalabilità automatica non esegue lo scale up abbastanza rapidamente per la tua applicazione, esegui il provisioning di min_replicas sufficienti per gestire il traffico di riferimento previsto.

Aggiorna la configurazione della scalabilità

Se hai specificato DedicatedResources o AutomaticResources durante il deployment del modello, 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 disattiva il logging del contenitore.

{
  "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 modificare il tipo di macchina o passare da DedicatedResources a AutomaticResources o viceversa. Gli unici campi di configurazione della scalabilità che puoi modificare sono: min_replica, max_replica e AutoscalingMetricSpec (solo DedicatedResources).
• Devi elencare tutti i campi da aggiornare in updateMask. I campi non elencati vengono ignorati.
• DeployedModel deve essere in uno stato DEPLOYED. Può essere attiva al massimo un'operazione di mutazione per modello di cui è stato eseguito il deployment.
• mutateDeployedModel ti consente inoltre di attivare o disattivare il logging del contenitore. Per ulteriori informazioni, consulta la sezione Log di previsione online.

Annullare il deployment di un modello ed eliminare l'endpoint

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

Passaggi successivi

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