Exibir exibições de recursos

Você pode disponibilizar Feature Views online de duas maneiras:

• Implantação de modelos: implantar um modelo treinado com base em Exibições de Recursos. O ponto de extremidade consulta automaticamente os valores dos atributos na loja online, com base na linhagem rastreada quando o modelo foi registrado. Use isso para atender a previsões de modelo.
• Serviço de features: implante um FeatureSpec que referencie Feature Views diretamente, sem um modelo. O endpoint retorna os valores da feature consultados. Use isso quando um aplicativo precisar de valores de recurso em vez de previsões de modelo.

Ambas as abordagens leem valores de atributos pré-computados de um armazenamento online, portanto você deve primeiro materializar os atributos em um armazenamento online.

Modelos treinados usando recursos do Databricks rastreiam automaticamente a linhagem para os recursos em que foram treinados. Quando implantados como pontos de extremidade de serviço de modelo, esses modelos usam o Catálogo do Unity para procurar recursos em lojas online.

Permissões

Para disponibilizar uma funcionalidade, o principal que cria o ponto de extremidade do Serviço de Modelo deve ter SELECT na tabela do Unity Catalog que dá suporte à funcionalidade materializada. Pesquisas online são lidas diretamente da tabela materializada, portanto, o nível SELECT da tabela é o que concede acesso de serviço. Para obter a descrição do privilégio, consulte SELECT.

Como uma tabela materializada pode conter mais de um recurso, conceder SELECT a ela concede acesso a todos os recursos dessa tabela, não apenas ao que você pretende atender. Antes de conceder acesso para veiculação, confirme que todas as funcionalidades que compartilham a tabela podem ser compartilhadas com o principal. Para limitar a exposição, materialize os atributos sensíveis separadamente.

Para conceder esse acesso sem resolver tabelas manualmente, use FeatureEngineeringClient.grant_feature_serving_access. Dado um modelo ou uma especificação de funcionalidade, ele resolve cada funcionalidade para sua tabela online, concede SELECT (juntamente com USE CATALOG e USE SCHEMA) nessas tabelas às identidades especificadas e retorna um relatório de cada tabela e das funcionalidades adicionais que a concessão expõe. Passe dry_run=True para visualizar o relatório antes da concessão.

from databricks.feature_engineering import FeatureEngineeringClient

fe = FeatureEngineeringClient()

# Preview the tables and the features each grant would expose.
report = fe.grant_feature_serving_access(
    grant_to=["serving-principal@example.com"],
    model_uri="models:/main.ecommerce.fraud_model/1",
    dry_run=True,
)
print(report)

# Grant SELECT on the resolved online tables.
fe.grant_feature_serving_access(
    grant_to=["serving-principal@example.com"],
    model_uri="models:/main.ecommerce.fraud_model/1",
)

Implantar um ponto de extremidade de serviço de modelo

Você pode utilizar um ponto de extremidade de serviço de modelo existente ou criar um novo usando o SDK do Databricks. O modelo deve ser registrado no Catálogo do Unity.

O código a seguir mostra como criar um novo ponto de extremidade de serviço de modelo. Para saber mais, confira Criar modelo personalizado que atende pontos de extremidade.

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.serving import EndpointCoreConfigInput, ServedEntityInput

w = WorkspaceClient()

endpoint_name = "fraud-detection-endpoint"
model_name = "main.ecommerce.fraud_model"

w.serving_endpoints.create(
    name=endpoint_name,
    config=EndpointCoreConfigInput(
        name=endpoint_name,
        served_entities=[
            ServedEntityInput(
                entity_name=model_name,
                entity_version=1,
                max_provisioned_concurrency=4,
                min_provisioned_concurrency=0,
            )
        ],
    ),
)

Consultar o ponto de extremidade

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

response = w.serving_endpoints.query(
    name="fraud-detection-endpoint",
    dataframe_records=[
        {"user_id": "user_123", "transaction_time": "2026-03-01T12:00:00"},
    ],
)

Consultar o ponto de extremidade com recursos RequestSource

Se o modelo foi treinado com RequestSource recursos, o conteúdo da solicitação também deve incluir todas as RequestSource colunas. Essas colunas foram adicionadas à assinatura do modelo MLflow durante log_model, portanto, o esquema de API do ponto de extremidade reflete os campos de solicitação necessários.

response = w.serving_endpoints.query(
    name="fraud-detection-endpoint",
    dataframe_records=[
        {
            "user_id": "user_123",
            "transaction_time": "2026-03-01T12:00:00",
            "transaction_amount": 275.30,  # RequestSource column
            "vendor_id": "v_42",           # RequestSource column (also used as entity key)
        },
    ],
)

As chaves de entidade são utilizadas para buscar recursos com o suporte de tabelas na loja online. RequestSource as colunas são passadas diretamente para o modelo.

Também é possível usar curl:

curl -X POST "https://<workspace>.cloud.databricks.com/serving-endpoints/<endpoint>/invocations" \
  -H "Authorization: Bearer $DATABRICKS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "dataframe_records": [
      {
        "user_id": "user_123",
        "transaction_time": "2026-03-01T12:00:00",
        "transaction_amount": 275.30,
        "vendor_id": "v_42"
      }
    ]
  }'

Fornecer funcionalidades com um FeatureSpec

Para disponibilizar Feature Views sem um modelo, crie um FeatureSpec que referencie as features e implante-o em um endpoint do Feature Serving. O endpoint retorna os valores dos atributos consultados para as chaves de entidade na requisição.

Os recursos devem ser registrados no Unity Catalog e materializados em um armazenamento online antes de criar o endpoint.

from databricks.feature_engineering import FeatureEngineeringClient
from databricks.feature_engineering.entities.feature_serving_endpoint import (
    EndpointCoreConfig,
    ServedEntity,
)

fe = FeatureEngineeringClient()

# 1. Retrieve a registered Feature View
agg_feature = fe.get_feature(full_name="main.ecommerce.amount_sum_sliding_7d_1d")

# 2. Create a FeatureSpec that includes the Feature View
feature_spec_name = "main.ecommerce.transaction_feature_spec"
fe.create_feature_spec(name=feature_spec_name, features=[agg_feature])

# 3. Deploy a Feature Serving endpoint backed by the FeatureSpec
fe.create_feature_serving_endpoint(
    name="transaction-features",
    config=EndpointCoreConfig(
        served_entities=ServedEntity(
            feature_spec_name=feature_spec_name,
            workload_size="Small",
            scale_to_zero_enabled=True,
        )
    ),
)

Consulte o endpoint com as chaves de entidade usadas para buscar os atributos materializados:

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

response = w.serving_endpoints.query(
    name="transaction-features",
    dataframe_records=[{"user_id": "user_123"}],
)

Para saber mais sobre os endpoints de Feature Serving, consulte endpoints de Feature Serving.