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 endpoint busca ou calcula automaticamente os valores dos atributos, usando a linhagem registrada 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 ponto de extremidade retorna as saídas de recursos solicitadas. Use isso quando um aplicativo precisar de valores de recurso em vez de previsões de modelo.

Ambas as abordagens suportam recursos pré-computados e sob demanda. Os recursos folha com suporte de tabela e fluxo devem ter materializações online suportadas. RequestSource fornece valores a partir da solicitação e CustomUDF calcula recursos sob demanda. Para um CustomUDF com FeatureViewSource, o serviço resolve as dependências upstream e avalia o grafo de dependência de recursos automaticamente.

Registre as funcionalidades solicitadas e todas as suas funcionalidades transitivas a montante no Catálogo Unity. Materialize apenas os recursos folha com suporte de tabela e fluxo, não os recursos de tempo de solicitação ou derivados CustomUDF.

Permissions

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 do Serviço de Modelo

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

Se uma CustomUDF usar uma função definida pelo usuário (UDF) que importa pacotes do Python, passe-os explicitamente por meio de extra_pip_requirements quando você chamar log_model. Veja Dependências UDF personalizadas.

O código a seguir mostra como criar um novo Ponto de extremidade do Serviço de Modelo. Para saber mais, confira Criar Pontos de extremidade do Serviço de Modelo personalizados.

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. Uma ColumnSelection característica pode passar um RequestSource valor para o modelo. Uma CustomUDF característica transforma suas entradas de solicitação antes que o modelo use o resultado.

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 apenas as saídas de características solicitadas na especificação. Ele calcula valores intermediários automaticamente sem retorná-los, a menos que você também solicite essas características.

Registre todos os recursos no Catálogo do Unity e crie materializações online suportadas para os recursos folha com suporte de tabela e fluxo antes de criar o ponto de extremidade.

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 pontos de extremidade do Serviço de Recursos, consulte Serviço de tabelas de recursos.

Funcionalidades do Serve CustomUDF e suas dependências

Este exemplo é compatível com as funcionalidades de transação e margem definidas nos exemplos CustomUDF e FeatureViewSource. Use databricks-feature-engineering a versão 0.18.0 ou superior para essas APIs de Visualizações de Funcionalidades.

• log_transaction_amount aplica main.ecommerce.log_amount_udf ao valor de transaction_amount da solicitação usando NumPy.
• margin usa FeatureViewSource para calcular uma margem a partir de revenue_sum_7d e cost_sum_7d. Esses recursos upstream usam customer_id como chave de entidade e event_time como coluna de séries temporais.

Registre os recursos de saída e todos os recursos upstream antes de criar a especificação. Para este exemplo, materialize online apenas os recursos folha revenue_sum_7d e cost_sum_7d. O serviço consulta seus valores e calcula margin para cada solicitação.

Recupere os objetos registrados Feature e os passe para create_feature_spec. Declare o NumPy para execução online mesmo que já esteja listado na cláusula da ENVIRONMENT UDF:

from databricks.feature_engineering import FeatureEngineeringClient

fe = FeatureEngineeringClient()
log_transaction_amount = fe.get_feature(
    full_name="main.ecommerce.log_transaction_amount"
)
margin = fe.get_feature(full_name="main.ecommerce.margin")

fe.create_feature_spec(
    name="main.ecommerce.derived_transaction_features",
    features=[log_transaction_amount, margin],
    extra_pip_requirements=["numpy==1.26.4"],
)

Siga os passos de criação de endpoint acima com feature_spec_name="main.ecommerce.derived_transaction_features" e um nome de endpoint como derived-transaction-features. Depois que o endpoint estiver pronto, forneça a chave de consulta e o valor do tempo de requisição:

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()
response = w.serving_endpoints.query(
    name="derived-transaction-features",
    dataframe_records=[
        {"customer_id": "customer_123", "transaction_amount": 99.0},
    ],
)

A resposta contém apenas os pedidos log_transaction_amount e margin resultados, não os valores intermediários de receita e custo. Para formatos de dependência, permissões de roda e solução de problemas de instalação, veja Adicionar dependências em Python.