Fonctionnalité Points de terminaison de service

Databricks Feature Serving met les données de la plateforme Databricks à la disposition des modèles ou applications déployé(e)s en dehors d’Azure Databricks. Les points de terminaison Feature Serving se mettent automatiquement à l’échelle pour s’adapter au trafic en temps réel et fournissent un service à haute disponibilité et à faible latence pour mettre en service les fonctionnalités. Cette page décrit comment configurer et utiliser Feature Serving. Pour obtenir un tutoriel pas à pas, consultez Exemple : déployer et interroger un point de terminaison de mise en service des fonctionnalités.

Lorsque vous mettez en service un modèle créé à l’aide de fonctionnalités de Databricks grâce à Service de modèles Mosaic AI, le modèle recherche et transforme automatiquement les fonctionnalités pour les requêtes d’inférence. Avec Databricks Feature Serving, vous pouvez mettre en service des données structurées pour les applications de génération augmentée de récupération (RAG), ainsi que les fonctionnalités requises pour d’autres applications, comme les modèles mis en service en dehors de Databricks ou toute autre application nécessitant des fonctionnalités basées sur les données dans Unity Catalog.

Pourquoi utiliser Feature Serving ?

Databricks Feature Serving fournit une interface unique qui met en service des fonctionnalités pré-matérialisées et à la demande. Il offre également les avantages suivants :

• Simplicité. Databricks gère l’infrastructure. Avec un seul appel d’API, Databricks crée un environnement de mise en service prêt pour la production.
• Haute disponibilité et scalabilité. Les points de terminaison Feature Serving effectuent automatiquement un scale-up et un scale-down pour s’adapter au volume des requêtes de mise en service.
• Sécurité. Les points de terminaison sont déployés dans une limite réseau sécurisée et utilisent un calcul dédié qui se termine à la suppression du point de terminaison ou sa mise à l’échelle vers zéro.

Conditions requises

• Databricks Runtime 14.2 ML ou version ultérieure.
• Pour utiliser l’API Python, Feature Serving nécessite databricks-feature-engineering version 0.1.2 ou ultérieure, qui est intégré à Databricks Runtime 14.2 ML. Pour les versions antérieures de Databricks Runtime ML, installez manuellement la version requise à l’aide de %pip install databricks-feature-engineering>=0.1.2. Si vous utilisez un notebook Databricks, redémarrez le noyau Python en exécutant cette commande dans une nouvelle cellule : dbutils.library.restartPython().
• Pour utiliser le kit de développement logiciel (SDK) Databricks, Feature Serving nécessite databricks-sdk version 0.18.0 ou ultérieure. Installez manuellement la version requise à l’aide de %pip install databricks-sdk>=0.18.0. Si vous utilisez un notebook Databricks, redémarrez le noyau Python en exécutant cette commande dans une nouvelle cellule : dbutils.library.restartPython().

Databricks Feature Serving fournit une IU et plusieurs options programmatiques pour créer, mettre à jour, interroger et supprimer des points de terminaison. Cet article comprend des instructions pour chacune des options suivantes :

• IU Databricks
• API REST
• API Python
• Kit de développement logiciel (SDK) Databricks

Pour utiliser l’API REST ou le kit de développement logiciel (SDK) des déploiements MLflow, vous devez disposer d’un jeton d’API Databricks.

Authentification pour Feature Serving

Pour plus d’informations sur l’authentification, consultez Autoriser l’accès aux ressources Azure Databricks.

Créez une classe FeatureSpec

Un FeatureSpec est un ensemble de fonctionnalités et fonctions défini par l’utilisateur. Vous pouvez combiner des fonctionnalités et des fonctions dans un FeatureSpec. Les FeatureSpecs sont stockés dans Unity Catalog et et gérés par ce dernier et s’affichent dans Catalog Explorer.

Les tables spécifiées dans un FeatureSpec doivent être publiées dans un magasin de fonctionnalités en ligne ou un magasin en ligne tiers. Consultez les magasins de fonctionnalités Databricks Online.

Vous devez créer un databricks-feature-engineering à l’aide du package FeatureSpec.

Tout d’abord, définissez la fonction :

from unitycatalog.ai.core.databricks import DatabricksFunctionClient

client = DatabricksFunctionClient()

CATALOG = "main"
SCHEMA = "default"

def difference(num_1: float, num_2: float) -> float:
  """
  A function that accepts two floating point numbers, subtracts the second one
  from the first, and returns the result as a float.

  Args:
      num_1 (float): The first number.
      num_2 (float): The second number.

  Returns:
      float: The resulting difference of the two input numbers.
  """
  return num_1 - num_2

client.create_python_function(
  func=difference,
  catalog=CATALOG,
  schema=SCHEMA,
  replace=True
)

Vous pouvez ensuite utiliser la fonction dans un 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 num_1 - num_2.
    input_bindings={"num_1": "ytd_spend", "num_2": "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,
)

Spécifier les valeurs par défaut

Pour spécifier des valeurs par défaut pour les fonctionnalités, utilisez le default_values paramètre dans le FeatureLookup. Consultez l’exemple suivant :

feature_lookups = [
    FeatureLookup(
        table_name="ml.recommender_system.customer_features",
        feature_names=[
            "membership_tier",
            "age",
            "page_views_count_30days",
        ],
        lookup_key="customer_id",
        default_values={
          "age": 18,
          "membership_tier": "bronze"
        },
    ),
]

Si les colonnes de caractéristiques sont renommées à l’aide du rename_outputs paramètre, default_values doivent utiliser les noms de fonctionnalités renommés.

FeatureLookup(
  table_name = 'main.default.table',
  feature_names = ['materialized_feature_value'],
  lookup_key = 'id',
  rename_outputs={"materialized_feature_value": "feature_value"},
  default_values={
    "feature_value": 0
  }
)

Créer un point de terminaison

Le FeatureSpec définit le point de terminaison. Pour en savoir plus, consultez Créer des points de terminaison de mise en service de modèles personnalisés, la documentation sur l’API Python ou la documentation sur le kit de développement logiciel (SDK) Databricks.

Kit de développement logiciel (SDK) Databricks - Python

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"
      )
    ]
  )
)

API Python

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,
    )
  )
)

API REST

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
           }
       ]
   }'

Pour afficher le point de terminaison, cliquez sur Mise en service dans la barre latérale gauche de l’IU Databricks. Lorsque l’état est Prêt, le point de terminaison est prêt à répondre aux requêtes. Pour en savoir plus sur Service de modèles Mosaic AI, consultez Service de modèles Mosaic AI.

Enregistrer le DataFrame augmenté dans la table d’inférence

Pour les points de terminaison créés à partir de février 2025, vous pouvez configurer le modèle servant le point de terminaison pour consigner le DataFrame augmenté qui contient les valeurs de fonctionnalité recherchées et les valeurs de retour de fonction. Le DataFrame est enregistré dans la table d’inférence pour le modèle servi.

Pour obtenir des instructions sur le paramétrage de cette configuration, consultez DataFrames de recherche de fonctionnalités de journal des tables d’inférence.

Pour plus d’informations sur les tables d’inférence, consultez les tables d’inférence pour la surveillance et le débogage des modèles.

Obtenir un point de terminaison

Vous pouvez obtenir les métadonnées et le statut d’un point de terminaison à l’aide du kit de développement logiciel (SDK) Databricks ou l’API Python.

Kit de développement logiciel (SDK) Databricks - Python

from databricks.sdk import WorkspaceClient
workspace = WorkspaceClient()

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

API Python

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

Obtenir le schéma d’un point de terminaison

Vous pouvez utiliser le Kit de développement logiciel (SDK) Databricks ou l’API REST pour obtenir le schéma d’un point de terminaison. Pour en savoir plus sur le schéma de point de terminaison, consultez Obtenir un schéma de point de terminaison de mise en service de modèles.

Kit de développement logiciel (SDK) Databricks - Python

from databricks.sdk import WorkspaceClient
workspace = WorkspaceClient()

# Create endpoint
endpoint = workspace.serving_endpoints.get_open_api(name="customer-features")

API REST

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"

Interroger un point de terminaison

Vous pouvez interroger un point de terminaison à l’aide de l’API REST, du kit de développement logiciel (SDK) de déploiements MLflow ou l’IU de mise en service.

Le code suivant montre comment configurer des informations d’identification et créer le client en cas d’utilisation du kit de développement logiciel (SDK) de déploiements MLflow.

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

  # Set up the client
  import mlflow.deployments

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

Interroger un point de terminaison à l’aide d’API

Cette section inclut des exemples d’interrogation d’un point de terminaison à l’aide de l’API REST ou du kit de développement logiciel (SDK) de déploiements MLflow.

Kit de développement logiciel (SDK) de déploiements MLflow

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},
        ]
    },
)

API REST

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}
      ]}'

Interroger un point de terminaison à l’aide de l’IU

Vous pouvez interroger un point de terminaison de mise en service directement à partir de l’IU de mise en service. L’IU inclut des exemples de code générés vous permettant d’interroger le point de terminaison.

1. Dans la barre latérale gauche de l’espace de travail Azure Databricks, cliquez sur Mise en service.

2. Cliquez sur le point de terminaison à interroger.

3. En haut de l’écran à droite, cliquez sur Interroger le point de terminaison.

   

4. Dans la zone Requête, saisissez le corps de la requête au format JSON.

5. Cliquez sur Envoyer la demande.

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

La boîte de dialogue Interroger le point de terminaison comporte des exemples de code générés dans curl, Python et SQL. Cliquez sur les onglets pour afficher et copier l’exemple de code.

Pour copier le code, cliquez sur l’icône de copie en haut de la zone de texte à droite.

Mettre à jour un point de terminaison

Vous pouvez mettre à jour un point de terminaison à l’aide de l’API REST, du kit de développement logiciel (SDK) Databricks ou de l’IU de mise en service.

Mettre à jour un point de terminaison à l’aide d’API

Kit de développement logiciel (SDK) Databricks - Python

from databricks.sdk import WorkspaceClient
workspace = WorkspaceClient()

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"
    )
  ]
)

API REST

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
        }
    ]'

Mettre à jour un point de terminaison à l’aide de l’IU

Pour utiliser l’IU de mise en service, procédez comme suit :

1. Dans la barre latérale gauche de l’espace de travail Azure Databricks, cliquez sur Mise en service.
2. Dans la table, cliquez sur le nom du point de terminaison à mettre à jour. L’écran du point de terminaison s’affiche alors.
3. En haut de l’écran à droite, cliquez sur Modifier le point de terminaison.
4. Dans la boîte de dialogue Modifier le point de terminaison de mise en service, modifiez les paramètres du point de terminaison si nécessaire.
5. Cliquez sur Mettre à jour pour enregistrer vos modifications.

Supprimer un point de terminaison

Vous pouvez supprimer un point de terminaison à l’aide de l’API REST, du kit de développement logiciel (SDK) Databricks, de l’API Python, ou de l’IU de mise en service.

Supprimer un point de terminaison à l’aide d’API

Kit de développement logiciel (SDK) Databricks - Python

from databricks.sdk import WorkspaceClient
workspace = WorkspaceClient()

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

API Python

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

API REST

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

Supprimer un point de terminaison à l’aide de l’IU

Pour supprimer un point de terminaison à l’aide de l’IU de mise en service, procédez comme suit :

1. Dans la barre latérale gauche de l’espace de travail Azure Databricks, cliquez sur Mise en service.
2. Dans la table, cliquez sur le nom du point de terminaison à supprimer. L’écran du point de terminaison s’affiche alors.
3. En haut à droite de l’écran, cliquez sur l’icône du , puis sélectionnez Supprimer.

Surveiller l’intégrité d’un point de terminaison

Pour en savoir plus sur les journaux et les mesures disponibles pour les points de terminaison Feature Serving, consultez Surveiller la qualité des modèles et l’intégrité des points de terminaison.

Contrôle d’accès

Pour plus d’informations sur les autorisations sur les points de terminaison de service des fonctionnalités, consultez Gérer les autorisations sur un point de terminaison de service de modèle.

Exemple de notebook

Ce notebook illustre comment le kit de développement logiciel (SDK) Databricks permet de créer un point de terminaison Feature Serving à l’aide de tables en ligne Databricks.

Exemple de notebook Feature Serving avec des tables en ligne

Obtenir le notebook