O que é Databricks recurso Serving?

Databricks Feature Serving disponibiliza os dados da plataforma Databricks para modelos ou aplicativos implantados fora do site Databricks. Feature Serving O ponto de extremidade é automaticamente escalonado para se ajustar ao tempo do tráfego real e fornecer um serviço de alta disponibilidade e baixa latência para o atendimento de recursos. Esta página descreve como configurar e usar o Feature Serving. Para obter um passo a passo tutorial, consulte implantado e consulte um Feature Serving endpoint .

Quando o senhor usa o site Mosaic AI Model Serving para atender a um modelo que foi criado usando o recurso do site Databricks, o modelo procura e transforma automaticamente o recurso para solicitações de inferência. Com o Databricks Feature Serving, o senhor pode servir dados estruturados para aplicativos de geração aumentada de recuperação (RAG), bem como recursos necessários para outros aplicativos, como modelos servidos fora do Databricks ou qualquer outro aplicativo que exija recursos baseados em dados no Unity Catalog.

quando usar recurso servindo

Por que usar o recurso Serving?

O Databricks recurso Serving oferece uma interface única que atende a recursos pré-materializados e sob demanda. Ele também inclui os seguintes benefícios:

  • Simplicidade. Databricks cuida da infraestrutura. Com uma única chamada de API, o Databricks cria um ambiente de serviço pronto para produção.

  • Alta disponibilidade e escalabilidade. Recurso O endpoint de atendimento aumenta e diminui automaticamente para se ajustar ao volume de solicitações de atendimento.

  • Segurança. Os endpoints são implantados em um limite de rede seguro e usam compute dedicada que termina quando o endpoint é excluído ou dimensionado para zero.

Requisitos

  • Databricks Runtime 14.2 ML ou acima.

  • Para usar a API do Python, o recurso Serving requer a versão 0.1.2 do databricks-feature-engineering ou acima, que é incorporado ao Databricks Runtime 14.2 ML. Para versões anteriores do Databricks Runtime ML, instale manualmente a versão necessária usando %pip install databricks-feature-engineering>=0.1.2. Se estiver usando um Databricks Notebook, o senhor deverá reiniciar o kernel do Python executando este comando em uma nova célula: dbutils.library.restartPython().

  • Para usar o SDK da Databricks, o recurso Serving requer a versão databricks-sdk 0.18.0 ou superior. Para instalar manualmente a versão necessária, use %pip install databricks-sdk>=0.18.0. Se estiver usando um Databricks Notebook, o senhor deverá reiniciar o kernel do Python executando este comando em uma nova célula: dbutils.library.restartPython().

O Databricks recurso Serving fornece uma interface de usuário e várias opções programáticas para criar, atualizar, consultar e excluir endpoints. Este artigo inclui instruções para cada uma das opções a seguir:

  • IU da Databricks

  • API REST

  • API do Python

  • SDK da Databricks

Para usar o REST API ou MLflow Deployments SDK, o senhor deve ter um token Databricks API .

Importante

Como prática recomendada de segurança para cenários de produção, a Databricks recomenda que o senhor use tokens OAuth máquina a máquina para autenticação durante a produção.

Para testes e desenvolvimento, o Databricks recomenda o uso de um access token pessoal pertencente à entidade de serviço em vez de usuários do workspace. Para criar o site tokens para uma entidade de serviço, consulte gerenciar tokens para uma entidade de serviço.

Autenticação para recurso Serving

Para obter informações sobre autenticação, consulte Autenticar o acesso a Databricks recurso.

Crie um FeatureSpec

Um FeatureSpec é um conjunto de recursos e funções definido pelo usuário. Você pode combinar recurso e funções em um FeatureSpec. FeatureSpecs são armazenados e gerenciados pelo Unity Catalog e aparecem no Catalog Explorer.

As tabelas especificadas em FeatureSpec devem ser publicadas em uma tabela on-line ou em um armazenamento on-line de terceiros. Consulte Use online tables for tempo real Feature Serving ou Third-party online stores.

O senhor deve usar o pacote databricks-feature-engineering para criar um FeatureSpec.

from databricks.feature_engineering import (
  FeatureFunction,
  FeatureLookup,
  FeatureEngineeringClient,
)

fe = FeatureEngineeringClient()

features = [
  # Lookup column `average_yearly_spend` and `country` from a table in UC by the input `user_id`.
  FeatureLookup(
    table_name="main.default.customer_profile",
    lookup_key="user_id",
    feature_names=["average_yearly_spend", "country"]
  ),
  # Calculate a new feature called `spending_gap` - the difference between `ytd_spend` and `average_yearly_spend`.
  FeatureFunction(
    udf_name="main.default.difference",
    output_name="spending_gap",
    # Bind the function parameter with input from other features or from request.
    # The function calculates a - b.
    input_bindings={"a": "ytd_spend", "b": "average_yearly_spend"},
  ),
]

# Create a `FeatureSpec` with the features defined above.
# The `FeatureSpec` can be accessed in Unity Catalog as a function.
fe.create_feature_spec(
  name="main.default.customer_features",
  features=features,
)

Crie um ponto final

O FeatureSpec define o endpoint. Para obter mais informações, consulte Criar endpoint de modelo de serviço personalizado, a documentação da API do Python ou a documentação do SDK da Databricks para obter detalhes.

Observação

Para cargas de trabalho que são sensíveis à latência ou que exigem altas consultas por segundo, a servindo modelo oferece otimização de rota no endpoint personalizado da servindo modelo, consulte Configurar otimização de rota no endpoint da servindo.

curl -X POST -u token:$DATABRICKS_API_TOKEN ${WORKSPACE_URL}/api/2.0/serving-endpoints \
    -H 'Content-Type: application/json' \
    -d '"name": "customer-features",
   "config": {
       "served_entities": [
           {
               "entity_name": "main.default.customer_features",
               "workload_size": "Small",
               "scale_to_zero_enabled": true
           }
       ]
   }'

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

workspace = WorkspaceClient()

# Create endpoint
workspace.serving_endpoints.create(
  name="my-serving-endpoint",
  config = EndpointCoreConfigInput(
    served_entities=[
    ServedEntityInput(
        entity_name="main.default.customer_features",
        scale_to_zero_enabled=True,
        workload_size="Small"
      )
    ]
  )
)

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

fe.create_feature_serving_endpoint(
  name="customer-features",
    config=EndpointCoreConfig(
    served_entities=ServedEntity(
      feature_spec_name="main.default.customer_features",
             workload_size="Small",
             scale_to_zero_enabled=True,
             instance_profile_arn=None,
    )
  )
)

Para ver o endpoint, clique em Serving na barra lateral esquerda da interface do usuário do Databricks. Quando o estado é Ready (Pronto), o site endpoint está pronto para responder às consultas. Para saber mais sobre o Mosaic AI Model Serving, consulte Mosaic AI Model Serving.

Obtenha um ponto final

O senhor pode usar o SDK da Databricks ou a API do Python para obter os metadados e o status de um endpoint.

endpoint = workspace.serving_endpoints.get(name="customer-features")
# print(endpoint)

endpoint = fe.get_feature_serving_endpoint(name="customer-features")
# print(endpoint)

Obter o esquema de um ponto de extremidade

O senhor pode usar a API REST para obter o esquema de um endpoint. Para obter mais informações sobre o esquema endpoint, consulte Get a servindo modelo endpoint schema.

ACCESS_TOKEN=<token>
ENDPOINT_NAME=<endpoint name>

curl "https://example.databricks.com/api/2.0/serving-endpoints/$ENDPOINT_NAME/openapi" -H "Authorization: Bearer $ACCESS_TOKEN" -H "Content-Type: application/json"

Consultar um endpoint

O senhor pode usar a REST API, o MLflow Deployments SDK ou a Serving UI para consultar um endpoint.

O código a seguir mostra como configurar as credenciais e criar o cliente ao usar o SDK do MLflow Deployments.

  # Set up credentials
  export DATABRICKS_HOST=...
  export DATABRICKS_TOKEN=...

  # Set up the client
  import mlflow.deployments

  client = mlflow.deployments.get_deploy_client("databricks")

Observação

Como prática recomendada de segurança ao se autenticar com ferramentas, sistemas, scripts e aplicativos automatizados, a Databricks recomenda que você use tokens OAuth.

Se o senhor usar a autenticação pessoal access token, a Databricks recomenda o uso de pessoal access tokens pertencente à entidade de serviço em vez de usuários workspace. Para criar o site tokens para uma entidade de serviço, consulte gerenciar tokens para uma entidade de serviço.

Consultar um ponto de extremidade usando APIs

Esta seção inclui exemplos de consulta a um endpoint usando a API REST ou o SDK do MLflow Deployments.

curl -X POST -u token:$DATABRICKS_API_TOKEN $ENDPOINT_INVOCATION_URL \
  -H 'Content-Type: application/json' \
  -d '{"dataframe_records": [
          {"user_id": 1, "ytd_spend": 598},
          {"user_id": 2, "ytd_spend": 280}
      ]}'

Importante

O exemplo a seguir usa a API predict() do SDK do MLflow Deployments. Esta API é experimental e a definição da API pode mudar.

import mlflow.deployments

client = mlflow.deployments.get_deploy_client("databricks")
response = client.predict(
    endpoint="test-feature-endpoint",
    inputs={
        "dataframe_records": [
            {"user_id": 1, "ytd_spend": 598},
            {"user_id": 2, "ytd_spend": 280},
        ]
    },
)

Consultar um endpoint usando a UI

O senhor pode consultar um serviço endpoint diretamente da Serving UI. A interface do usuário inclui exemplos de código gerados que o senhor pode usar para consultar o endpoint.

  1. Na barra lateral esquerda do Databricks workspace, clique em Serving.

  2. Clique no endpoint que você deseja query.

  3. No canto superior direito da tela, clique em endpointquery .

    botão de endpoint query

  4. Na caixa Solicitação , digite o corpo da solicitação no formato JSON.

  5. Clique em Enviar solicitação.

// Example of a request body.
{
  "dataframe_records": [
    {"user_id": 1, "ytd_spend": 598},
    {"user_id": 2, "ytd_spend": 280}
  ]
}

A caixa de diálogo do endpointquery inclui código de exemplo gerado em curl, Python e SQL. Clique na tab para view e copiar o código de exemplo.

caixa de diálogo de endpoint query

Para copiar o código, clique no ícone de cópia no canto superior direito da caixa de texto.

botão copiar na caixa de diálogo do endpoint query

Atualizar um ponto de extremidade

O senhor pode atualizar um endpoint usando a REST API, o Databricks SDK ou a Serving UI.

Atualizar um ponto de extremidade usando APIs 

curl -X PUT -u token:$DATABRICKS_API_TOKEN ${WORKSPACE_URL}/api/2.0/serving-endpoints/<endpoint_name>/config \
  -H 'Content-Type: application/json' \
  -d '"served_entities": [
        {
            "name": "customer-features",
            "entity_name": "main.default.customer_features_new",
            "workload_size": "Small",
            "scale_to_zero_enabled": True
        }
    ]'

workspace.serving_endpoints.update_config(
  name="my-serving-endpoint",
  served_entities=[
    ServedEntityInput(
      entity_name="main.default.customer_features",
      scale_to_zero_enabled=True,
      workload_size="Small"
    )
  ]
)

Atualizar um endpoint usando a UI

Siga estes passos para usar o Serving UI:

  1. Na barra lateral esquerda do Databricks workspace, clique em Serving.

  2. Na tabela, clique no nome do endpoint que o senhor deseja atualizar. A tela do endpoint é exibida.

  3. No canto superior direito da tela, clique em Editar endpoint.

  4. Na caixa de diálogo Edit serving endpoint (Editar endpoint de serviço ), edite as configurações do endpoint conforme necessário.

  5. Clique em Update (Atualizar ) para salvar as alterações.

atualizar e endpoint

Excluir um ponto de extremidade

Aviso

Esta ação é irreversível.

O senhor pode excluir um endpoint usando a REST API, o Databricks SDK, a Python API ou a Serving UI.

Excluir um ponto de extremidade usando APIs 

curl -X DELETE -u token:$DATABRICKS_API_TOKEN ${WORKSPACE_URL}/api/2.0/serving-endpoints/<endpoint_name>

workspace.serving_endpoints.delete(name="customer-features")

fe.delete_feature_serving_endpoint(name="customer-features")

Excluir um endpoint usando a interface do usuário

Siga estes passos para excluir um endpoint usando a UI do Serving:

  1. Na barra lateral esquerda do Databricks workspace, clique em Serving.

  2. Na tabela, clique no nome do endpoint que o senhor deseja excluir. A tela do endpoint é exibida.

  3. No canto superior direito da tela, clique no menu kebab Menu Kebab e selecione Delete (Excluir).

excluir um endpoint

Monitorar a integridade de um endpoint

Para obter informações sobre os logs e as métricas disponíveis para os endpoints do recurso Serving, consulte Monitorar a qualidade do modelo e a integridade do site endpoint .

Controle de acesso

Para obter informações sobre permissões no endpoint Feature Serving, consulte gerenciar permissões em seu modelo de serviço endpoint.

Exemplo de notebook

Este Notebook ilustra como usar o Databricks SDK para criar um Feature Serving endpoint usando Databricks Online Tables.

Exemplo de recurso Serving Notebook com tabelas on-line

Abra o bloco de anotações em outra guia