Crie um ponto final público

Para implementar um modelo através da CLI gcloud ou da API Vertex AI, tem de criar primeiro um ponto final público.

Se já tiver um ponto final público existente, pode ignorar este passo e prosseguir para Implementar um modelo através da CLI gcloud ou da API Vertex AI.

Este documento descreve o processo de criação de um novo ponto final público.

O limite de tempo predefinido do pedido para um ponto final público dedicado é de 10 minutos. Na API Vertex AI e no SDK Vertex AI para Python, pode, opcionalmente, especificar um limite de tempo de pedido diferente adicionando um objeto clientConnectionConfig que contenha um novo valor inferenceTimeout, conforme mostrado no exemplo seguinte. O valor de tempo limite máximo é de 3600 segundos (1 hora).

Google Cloud consola

  1. Na Google Cloud consola, na secção Vertex AI, aceda à página Previsão online.
    Aceda à página Previsão online
  2. Clique em Criar.
  3. No painel Novo ponto final:
    1. Introduza o Nome do ponto final.
    2. Selecione Padrão para o tipo de acesso.
    3. Selecione a caixa de verificação Ativar DNS dedicado.
    4. Clique em Continuar.
  4. Clique em Concluído.

REST

Antes de usar qualquer um dos dados do pedido, faça as seguintes substituições:

  • LOCATION_ID: a sua região.
  • PROJECT_ID: o seu ID do projeto.
  • ENDPOINT_NAME: o nome a apresentar do ponto final.
  • INFERENCE_TIMEOUT_SECS: (Opcional) Número de segundos no campo inferenceTimeout opcional.

Método HTTP e URL: 

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

Corpo JSON do pedido: 

{
  "display_name": "ENDPOINT_NAME"
  "dedicatedEndpointEnabled": true,
  "clientConnectionConfig": {
    "inferenceTimeout": {
      "seconds": INFERENCE_TIMEOUT_SECS
    }
  }
}

Para enviar o seu pedido, expanda uma destas opções:

Deve receber uma resposta JSON semelhante à seguinte:

{
  "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"
    }
  }
}
Pode sondar o estado da operação até que a resposta inclua "done": true.

Python

Antes de experimentar este exemplo, siga as Pythoninstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Python Vertex AI.

Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

Substitua o seguinte:

  • PROJECT_ID: o ID do seu projeto.
  • LOCATION_ID: a região onde está a usar o Vertex AI.
  • ENDPOINT_NAME: o nome a apresentar do ponto final.
  • INFERENCE_TIMEOUT_SECS: (Opcional) Número de segundos no valor inference_timeout opcional.
from google.cloud import aiplatform

PROJECT_ID = "PROJECT_ID"
LOCATION = "LOCATION_ID"
ENDPOINT_NAME = "ENDPOINT_NAME"
INFERENCE_TIMEOUT_SECS = "INFERENCE_TIMEOUT_SECS"

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

dedicated_endpoint = aiplatform.Endpoint.create(
    display_name=DISPLAY_NAME,
    dedicated_endpoint_enabled=True,
    sync=True,
    inference_timeout=INFERENCE_TIMEOUT_SECS,
)

Configuração do limite de tempo de inferência

A duração do limite de tempo predefinido para pedidos de inferência é de 600 segundos (10 minutos). Este limite de tempo é aplicado se não for especificado um limite de tempo de inferência explícito durante a criação do ponto final. O valor de tempo limite máximo permitido é de uma hora.

Para configurar o limite de tempo de inferência durante a criação do ponto final, use o parâmetro inference_timeout, conforme demonstrado no seguinte fragmento do código:

timeout_endpoint = aiplatform.Endpoint.create(
    display_name="dedicated-endpoint-with-timeout",
    dedicated_endpoint_enabled=True,
    inference_timeout=1800,  # Unit: Seconds
)

As modificações à definição de tempo limite de inferência após a criação do ponto final podem ser realizadas através do método EndpointService.UpdateEndpointLongRunning. O método EndpointService.UpdateEndpoint não é compatível com esta modificação.

Registo de pedidos-respostas

A funcionalidade de registo de pedidos/respostas captura as interações da API. No entanto, para agir em conformidade com as limitações do BigQuery, as cargas úteis com mais de 10 MB são excluídas dos registos.

Para ativar e configurar o registo de pedidos e respostas durante a criação do ponto final, use os seguintes parâmetros, conforme ilustrado no fragmento de código subsequente:

logging_endpoint = aiplatform.Endpoint.create(
    display_name="dedicated-endpoint-with-logging",
    dedicated_endpoint_enabled=True,
    enable_request_response_logging=True,
    request_response_logging_sampling_rate=1.0,  # Default: 0.0
    request_response_logging_bq_destination_table="bq://test_logging",
    # If not set, a new BigQuery table will be created with the name:
    # bq://{project_id}.logging_{endpoint_display_name}_{endpoint_id}.request_response_logging
)

As modificações às definições de registo de pedidos e respostas após a criação do ponto final podem ser feitas através do método EndpointService.UpdateEndpointLongRunning. O método EndpointService.UpdateEndpoint não suporta esta modificação.

Crie um ponto final público partilhado

Google Cloud consola

  1. Na Google Cloud consola, na secção Vertex AI, aceda à página Previsão online.
    Aceda à página Previsão online
  2. Clique em Criar.
  3. No painel Novo ponto final:
    1. Introduza o Nome do ponto final.
    2. Selecione Padrão para o tipo de acesso.
    3. Clique em Continuar.
  4. Clique em Concluído.

gcloud

O exemplo seguinte usa o comando gcloud ai endpoints create:

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

Substitua o seguinte:

  • LOCATION_ID: a região onde está a usar o Vertex AI.
  • ENDPOINT_NAME: o nome a apresentar do ponto final.

A ferramenta Google Cloud CLI pode demorar alguns segundos a criar o ponto final.

REST

Antes de usar qualquer um dos dados do pedido, faça as seguintes substituições:

  • LOCATION_ID: a sua região.
  • PROJECT_ID: o seu ID do projeto.
  • ENDPOINT_NAME: o nome a apresentar do ponto final.

Método HTTP e URL: 

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

Corpo JSON do pedido: 

{
  "display_name": "ENDPOINT_NAME"
}

Para enviar o seu pedido, expanda uma destas opções:

Deve receber uma resposta JSON semelhante à seguinte:

{
  "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"
    }
  }
}
Pode sondar o estado da operação até que a resposta inclua "done": true.

Terraform

O exemplo seguinte usa o recurso do Terraform google_vertex_ai_endpoint para criar um ponto final.

Para saber como aplicar ou remover uma configuração do Terraform, consulte os comandos básicos do Terraform.

# 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

Antes de experimentar este exemplo, siga as Javainstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Java Vertex AI.

Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local. 


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

Antes de experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Node.js Vertex AI.

Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local. 

/**
 * 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

Para saber como instalar ou atualizar o SDK Vertex AI para Python, consulte o artigo Instale o SDK Vertex AI para Python. Para mais informações, consulte a Python documentação de referência da 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

O que se segue?