O que é Databricks recurso Serving?

O Databricks recurso Serving torna os dados na plataforma Databricks disponíveis para modelos ou aplicativos implantados fora da Databricks. O endpoint de atendimento de recurso escala automaticamente para se ajustar ao tráfego em tempo real e fornecer um serviço de alta disponibilidade e baixa latência para o atendimento de recurso. Esta página descreve como configurar e usar o recurso Serving.

Quando o senhor usa o Databricks servindo modelo para servir um modelo que foi criado usando recurso do Databricks, o modelo procura e transforma automaticamente o recurso para solicitações de inferência. Com o Databricks Recurso Serving, o senhor pode servir dados estruturados para aplicativos de geração aumentada de recuperação (RAG), bem como recurso que são necessários para outros aplicativos, como modelos servidos fora do Databricks ou qualquer outro aplicativo que exija recurso com base 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 a API REST ou o SDK do MLflow Deployments, use a autenticação padrão do Databricks.

Autenticação para recurso Serving

Para obter informações sobre autenticação, consulte Autenticação para automação de Databricks - visão geral.

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 um armazenamento online ou em uma tabela online. Para informações sobre como publicar recurso em um armazenamento online, consulte Publicar recurso em um armazenamento online. Para informações sobre tabelas online, consulte Usar tabelas online para servir recursos em tempo real.

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",
    features=["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 Servindo na barra lateral esquerda da UI do Databricks. Quando o estado for Ready, o endpoint estará pronto para responder à query. Para saber mais sobre o modelo de operação do Databricks, consulte Modelo de operação do Databricks.

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)

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 usar o token de acesso pessoal pertencente à entidade de serviço em vez dos usuários workspace. Para criar tokens para entidades 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.

Notebook de Exemplo

O site Notebook a seguir ilustra como usar o SDK da Databricks para criar um endpoint de recurso Serving usando o Databricks Online Tables.

Exemplo de recurso Serving Notebook com tabelas on-line

Abra o bloco de anotações em outra guia

O site Notebook a seguir ilustra como usar o SDK da Databricks para criar um endpoint de recurso Serving usando um armazenamento on-line de terceiros.

recurso Servindo o exemplo Notebook com o DynamoDB

Abra o bloco de anotações em outra guia