Se usó la API de Cloud Translation para traducir esta página.

Obtener una predicción en línea

El servicio de predicción en línea de Vertex AI te permite realizar solicitudes síncronas a tu propio extremo del modelo de predicción.

En esta página, se muestra cómo enviar solicitudes a tu modelo para que pueda entregar predicciones en línea con baja latencia.

Antes de comenzar

Antes de comenzar a usar la API de Online Prediction, debes tener un proyecto y las credenciales adecuadas.

Sigue estos pasos antes de obtener una predicción en línea:

Configura un proyecto para Vertex AI.
Para obtener los permisos que necesitas para acceder a la Predicción en línea, pídele al administrador de IAM del proyecto que te otorgue el rol de usuario de predicción de Vertex AI (vertex-ai-prediction-user).

Para obtener información sobre este rol, consulta Cómo preparar permisos de IAM.
Crea y entrena un modelo de predicción que se dirija a uno de los contenedores admitidos.
Crea el clúster de predicción y asegúrate de que tu proyecto permita el tráfico externo entrante.
Exporta los artefactos de tu modelo para la predicción.
Implementa tu modelo en un extremo.
Muestra los detalles del recurso personalizado Endpoint de tu modelo de predicción:
```
kubectl --kubeconfig PREDICTION_CLUSTER_KUBECONFIG get endpoint PREDICTION_ENDPOINT -n PROJECT_NAMESPACE -o jsonpath='{.status.endpointFQDN}'
```
Reemplaza lo siguiente:
- PREDICTION_CLUSTER_KUBECONFIG: Es la ruta de acceso al archivo kubeconfig en el clúster de predicción.
- PREDICTION_ENDPOINT: El nombre del extremo.
- PROJECT_NAMESPACE: Es el nombre del espacio de nombres del proyecto de predicción.
El resultado debe mostrar el campo status, que muestra el nombre de dominio completamente calificado del extremo en el campo endpointFQDN. Registra la ruta de URL de este extremo para usarla en tus solicitudes.

Configura las variables de entorno

Si deseas enviar una solicitud al extremo de tu modelo con una secuencia de comandos de Python y configuraste una cuenta de servicio en tu proyecto para realizar llamadas autorizadas a la API de forma programática, puedes definir variables de entorno en la secuencia de comandos para acceder a valores como las claves de la cuenta de servicio durante la ejecución.

Sigue estos pasos para configurar las variables de entorno requeridas en una secuencia de comandos de Python:

Crea un notebook de JupyterLab para interactuar con la API de Online Prediction.
Crea una secuencia de comandos de Python en el notebook de JupyterLab.
Agrega el siguiente código a la secuencia de comandos de Python:
```
import os

os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "APPLICATION_DEFAULT_CREDENTIALS_FILENAME"
```
Reemplaza APPLICATION_DEFAULT_CREDENTIALS_FILENAME por el nombre del archivo JSON que contiene las claves de la cuenta de servicio que creaste en el proyecto, como my-service-key.json.
Guarda la secuencia de comandos de Python con un nombre, como prediction.py.
Ejecuta la secuencia de comandos de Python para establecer las variables de entorno:
```
python SCRIPT_NAME
```
Reemplaza SCRIPT_NAME por el nombre que le diste a tu secuencia de comandos de Python, como prediction.py.

Envía una solicitud a un extremo

Realiza una solicitud al extremo del modelo para obtener una predicción en línea:

curl

Sigue estos pasos para realizar una solicitud de curl:

Crea un archivo JSON llamado request.json para el cuerpo de la solicitud.

Debes agregar y dar formato a tu entrada para la predicción en línea con los detalles del cuerpo de la solicitud que requiere el contenedor de destino.
Obtén un token de autenticación.
Realiza la solicitud:
```
curl -X POST -H "Content-Type: application/json; charset=utf-8" -H "Authorization: Bearer TOKEN"
https://ENDPOINT:443/v1/model:predict -d @request.json
```
Reemplaza lo siguiente:
- TOKEN: El token de autenticación que obtuviste
- ENDPOINT: Es el extremo del modelo para la solicitud de predicción en línea.

Si la solicitud se realiza correctamente, recibirás una respuesta JSON a tu solicitud de predicción en línea.

En el siguiente resultado, se muestra un ejemplo:

{
    "predictions": [[-357.10849], [-171.621658]
    ]
}

Para obtener más información sobre las respuestas, consulta los detalles del cuerpo de la respuesta.

Python

Sigue estos pasos para usar el servicio de predicción en línea desde una secuencia de comandos de Python:

Crea un archivo JSON llamado request.json para el cuerpo de la solicitud.

Debes agregar y dar formato a tu entrada para la predicción en línea con los detalles del cuerpo de la solicitud que requiere el contenedor de destino.
Instala la versión más reciente de la biblioteca cliente de Vertex AI Platform.
Configura las variables de entorno necesarias en una secuencia de comandos de Python.
Autentica tu solicitud a la API.

Agrega el siguiente código a la secuencia de comandos de Python que creaste:

import json
import os
from typing import Sequence

import grpc
from absl import app
from absl import flags

from google.auth.transport import requests
from google.protobuf import json_format
from google.protobuf.struct_pb2 import Value
from google.cloud.aiplatform_v1.services import prediction_service

_INPUT = flags.DEFINE_string("input", None, "input", required=True)
_HOST = flags.DEFINE_string("host", None, "Prediction endpoint", required=True)
_ENDPOINT_ID = flags.DEFINE_string("endpoint_id", None, "endpoint id", required=True)

os.environ["GRPC_DEFAULT_SSL_ROOTS_FILE_PATH"] = "path-to-ca-cert-file.cert"

# ENDPOINT_RESOURCE_NAME is a placeholder value that doesn't affect prediction behavior.
ENDPOINT_RESOURCE_NAME="projects/000000000000/locations/us-central1/endpoints/00000000000000"

def get_sts_token(host):
  creds = None
  try:
    creds, _ = google.auth.default()
    creds = creds.with_gdch_audience(host+":443")
    req = requests.Request()
    creds.refresh(req)
    print("Got token: ")
    print(creds.token)
  except Exception as e:
    print("Caught exception" + str(e))
    raise e
return creds.token

# predict_client_secure builds a client that requires TLS
def predict_client_secure(host, token):
  with open(os.environ["GRPC_DEFAULT_SSL_ROOTS_FILE_PATH"], 'rb') as f:
    channel_creds = grpc.ssl_channel_credentials(f.read())

  call_creds = grpc.access_token_call_credentials(token)

  creds = grpc.composite_channel_credentials(
    channel_creds,
    call_creds,
  )

  client = prediction_service.PredictionServiceClient(
      transport=prediction_service.transports.grpc.PredictionServiceGrpcTransport(
       channel=grpc.secure_channel(target=host+":443", credentials=creds)))

  return client

def predict_func(client, instances):
  resp = client.predict(
    endpoint=ENDPOINT_RESOURCE_NAME,
    instances=instances,
    metadata=[("x-vertex-ai-endpoint-id", _ENDPOINT_ID.value)]
  )
  print(resp)

def main(argv: Sequence[str]):
  del argv  # Unused.
  with open(_INPUT.value) as json_file:
      data = json.load(json_file)
      instances = [json_format.ParseDict(s, Value()) for s in data["instances"]]

  token = get_sts_token(_HOST.value)
  client = predict_client_secure(_HOST.value, token)
  predict_func(client=client, instances=instances)

if __name__=="__main__":
  app.run(main)

Guarda la secuencia de comandos de Python con un nombre, como prediction.py.
Realiza la solicitud al servidor de predicción:
```
python SCRIPT_NAME --input request.json \
    --host ENDPOINT \
    --endpoint_id ENDPOINT_ID \
```
Reemplaza lo siguiente:
- SCRIPT_NAME: Es el nombre de la secuencia de comandos de Python, como prediction.py.
- ENDPOINT: Es el extremo del modelo para la solicitud de predicción en línea.
- ENDPOINT_ID: Es el valor del ID del extremo.

Si la solicitud se realiza correctamente, recibirás una respuesta JSON a tu solicitud de predicción en línea. Para obtener más información sobre las respuestas, consulta los detalles del cuerpo de la respuesta.