Nota:
El acceso a esta página requiere autorización. Puede intentar iniciar sesión o cambiar directorios.
El acceso a esta página requiere autorización. Puede intentar cambiar los directorios.
Importante
Esta característica se encuentra en versión preliminar privada. Para probarlo, póngase en contacto con su contacto de Azure Databricks.
Los Declarative Automation Bundles (anteriormente conocidos como Databricks Asset Bundles) te permiten validar, desplegar y ejecutar programáticamente recursos de Azure Databricks como las Feature Views y las pipelines que las materializan. Consulte ¿Qué son los conjuntos de automatización declarativos?.
Este tutorial crea un paquete que declara cuatro Feature Views y las materializa de tres maneras: dos funciones por lotes escritas tanto para una tienda offline como para una tienda online, una función de streaming escrita continuamente para una tienda online, y una función de streaming con ventana en diente de sierra, que se materializa en una tienda offline y una online en modo batch y en la tienda online en modo streaming. Luego cambias la configuración, vuelves a desplegar y desmontas todo.
Declarar características en un paquete te da las mismas definiciones en cada espacio de trabajo donde despliegues, revisadas como fuente junto con el resto de tu proyecto. Es la alternativa declarativa a llamar a create_feature y a materialize_features desde un cuaderno. Consulte Vistas de funciones.
Cada paso muestra la configuración tanto en YAML como en Python. Elige un idioma y la página sigue tu elección.
Requirements
- Databricks CLI versión 1.24.0 o superior. Ejecute
databricks --versionpara comprobarlo. Consulte Instalación o actualización de la CLI de Databricks. - El motor de despliegue directo. Los recursos
featuresymaterialization_setsno son compatibles con el motor de despliegue de Terraform. Consulta la compatibilidad de recursos. - Un área de trabajo habilitada para el Catálogo de Unity. Vea Requisitos.
- Permiso para crear entidades y materializarlas. Consulte Permisos.
- Una tienda online existente. Consulte Crear una tienda online.
- Una tabla Delta existente con una columna de entidad y una columna de marca de tiempo, para la materialización por lotes. Consulte las tablas de Azure Databricks.
- Un Stream existente, para la materialización del Stream. Ver Crear un stream.
Una tabla fuente y un Stream tienen cada uno su propio ciclo de vida y ninguno es un recurso bundle. Créalos primero y haz referencia a ellos por nombre en el paquete, como hace el Paso 3 para la tabla y el Paso 4 para el Stream.
Recursos del Feature Store en un paquete
Este tutorial declara dos tipos de recursos en Feature Store, y la diferencia entre ellos determina cuánto cuesta un despliegue.
- Feature View: la definición de una característica, que cubre su origen, su agregación y sus claves. Son metadatos ligeros. Consulta Vistas de Características y, para la referencia de configuración, feature.
- Conjunto de materialización: un grupo de features materializadas. Una característica materializada es una Vista de Características calculada en una tabla a través de pipelines o trabajos, así que esta es la parte pesada. Agrupar características materializadas en un solo conjunto indica a Azure Databricks que pueden calcularse juntas, por lo que las agrupa en el menor número de tablas y pipelines Lakeflow que las almacenen. Consulta Materializar vistas de características y, para la referencia de configuración, materialization_set y materialization_set.materialized_features.
Los pasos que siguen incluyen declarar características por lotes, una característica de streaming y una característica de streaming con una ventana de diente de sierra. Declara solo los que necesite tu proyecto. Para saber cómo funciona la materialización, consulta Materialize Feature Views.
Paso 1 Configuración de la autenticación
Primero, configura la autenticación entre la CLI de Databricks en tu máquina de desarrollo y tu espacio de trabajo de Azure Databricks. En esta página se supone que desea usar la autenticación de usuario a máquina (U2M) de OAuth y un perfil de configuración de Azure Databricks correspondiente denominado DEFAULT para la autenticación.
Nota:
La autenticación U2M es adecuada para probar estos pasos en tiempo real. Para flujos de trabajo totalmente automatizados, Databricks recomienda usar la autenticación de máquina a máquina (M2M) de OAuth en su lugar. Consulte las instrucciones de configuración de autenticación de M2M en Autorizar acceso de la entidad de servicio a Azure Databricks con OAuth.
Use el CLI de Databricks para iniciar la administración de tokens de OAuth localmente mediante la ejecución del siguiente comando para cada área de trabajo de destino.
En el comando siguiente, reemplace
<workspace-url>por la dirección URL de Azure Databricks por área de trabajo, por ejemplo,https://adb-1234567890123456.7.azuredatabricks.net.databricks auth login --host <workspace-url>La CLI de Databricks le pide que guarde la información que especificó como un perfil de configuración de Azure Databricks. Presione
Enterpara aceptar el nombre del perfil sugerido o escriba el nombre de un perfil nuevo o existente. Cualquier perfil existente con el mismo nombre se sobrescribe con la información que ha introducido. Puede usar perfiles para cambiar rápidamente el contexto de autenticación entre varias áreas de trabajo.Para obtener una lista de los perfiles existentes, en una terminal o una línea de comandos por separado, use la CLI de Databricks para ejecutar el comando
databricks auth profiles. Para ver la configuración existente de un perfil específico, ejecute el comandodatabricks auth env --profile <profile-name>.En el explorador web, complete las instrucciones en pantalla para iniciar sesión en el área de trabajo de Azure Databricks.
Para ver el valor actual del token de OAuth de un perfil y la próxima marca de tiempo de expiración del token, ejecute uno de los siguientes comandos:
databricks auth token --host <workspace-url>databricks auth token -p <profile-name>databricks auth token --host <workspace-url> -p <profile-name>
Si tiene varios perfiles con el mismo valor de
--host, es posible que tenga que especificar las opciones--hosty-ppara ayudar a la CLI de Databricks a encontrar la información correcta del token de OAuth coincidente.
Paso 2: crear el conjunto
Crea un directorio vacío para el paquete, con un databricks.yml archivo en su raíz y un resources directorio al lado.
YAML
Cada uno de los siguientes pasos añade un archivo debajo resources/ para declarar los recursos del bundle:
databricks.yml
resources/
batch_feature.yml
streaming_feature.yml
streaming_feature_sawtooth.yml
databricks.yml Contiene tres cosas:
- El nombre del bundle.
- La
includeentrada, que decide de qué archivos carga el paquete sus recursos. - Las variables, que contienen valores que los recursos pueden referenciar, como el catálogo, el esquema y los nombres de la fuente.
bundle:
name: feature-store-quickstart
include:
- resources/*.yml
variables:
catalog:
description: The catalog that features are written to.
default: main
schema:
description: The schema that features are written to.
default: features_demo
source_table:
description: The three-level name of the source Delta table.
default: main.features_demo.transactions
stream:
description: The three-level name of a Stream registered in Unity Catalog.
default: main.features_demo.events
online_store:
description: The online store that serves the features.
default: my_online_store
Declarar todo en databricks.yml en su lugar también funciona. Omite include y recopila las declaraciones de cada paso bajo un mismo resources mapeo:
bundle:
name: feature-store-quickstart
variables:
# The variables above.
resources:
features:
# The Feature Views from the following steps.
materialization_sets:
# The materialization sets from the following steps.
Python
Los recursos declarados en Python solo se encuentran mediante el python mapeo en databricks.yml. Sin él, el paquete se valida y se despliega con éxito pero no contiene recursos, así que añádelo ahora:
bundle:
name: feature-store-quickstart
python:
venv_path: .venv
resources:
- 'resources:load_resources'
variables:
catalog:
description: The catalog that features are written to.
default: main
schema:
description: The schema that features are written to.
default: features_demo
source_table:
description: The three-level name of the source Delta table.
default: main.features_demo.transactions
stream:
description: The three-level name of a Stream registered in Unity Catalog.
default: main.features_demo.events
online_store:
description: The online store that serves the features.
default: my_online_store
venv_path es el entorno virtual en el que la CLI de Databricks ejecuta este código. Cada entrada bajo resources nombra una función como <module>:<function>, que Databricks CLI llama para recopilar los recursos del paquete. Si se declara más de una <module>:<function> entrada bajo resources, la CLI de Databricks llama a todas las funciones y recopila los recursos que cada una devuelve.
Luego crea el proyecto y su entorno virtual, y añade el paquete:
uv init --bare
uv venv .venv
uv add databricks-bundles
Cree resources/__init__.py con la función que databricks.yml nombra:
from databricks.bundles.core import Bundle, Resources
def load_resources(bundle: Bundle) -> Resources:
resources = Resources()
# The following steps add resources here.
return resources
Para más información sobre la creación de paquetes en Python, incluyendo la plantilla del proyecto y los mutadores, consulta Configuración de paquetes en Python.
Paso 3: Añadir funciones por lotes
Estas dos Vistas de Características cuentan las transacciones por usuario durante siete días posteriores y 30 días posteriores, ambas recalculadas diariamente, y se materializan juntas en una tienda offline y una online.
Una vista de características por sí sola es solo una definición. El conjunto de materialización es lo que produce datos a partir de él.
Cada recurso lleva dos nombres.
transaction_count es la clave de recurso: un nombre que eliges, único dentro del conjunto, que usan los comandos databricks bundle para identificar el recurso y al que hacen referencia otras configuraciones. Por ejemplo, las dos características materializadas de transaction_count en el conjunto transactions hacen referencia al nombre de la Vista de Características como ${resources.features.transaction_count.full_name}, lo que indica al paquete que el conjunto depende de la Vista de Características transaction_count.
Debido a esta dependencia, transaction_count se crea antes del conjunto transactions cuando ambos se crean, y se elimina después cuando ambos son destruidos. Un nombre codificado como main.features_demo.transaction_count_7d, escrito sin ${}, omite esa dependencia y se despliega en un orden impredecible.
full_name es el nombre de tres niveles que eliges para la Feature View que se registrará en Unity Catalog y que consultas más adelante. Los dos nombres son independientes.
Una duración es un conteo de segundos con un sufijo s, como en 604800s para siete días. Consulta Especificar una duración para una ventana, fuente o función.
Cada entrada debajo materialized_features es un miembro materializado de la característica: una Vista de Característica materializada hacia un destino. Cada una de estas Vistas de Características se materializa tanto en un destino offline como en uno online, por lo que cada una aporta dos miembros materializados y cada miembro lleva su propio disparador. Ambas Feature Views escriben en el mismo destino offline y online, porque un conjunto tiene un destino offline y, como mucho, uno online.
YAML
Creación de resources/batch_feature.yml:
resources:
features:
transaction_count:
full_name: ${var.catalog}.${var.schema}.transaction_count_7d
description: Transactions per user over a trailing seven days
source:
delta_table_source:
full_name: ${var.source_table}
function:
aggregation_function:
count_function:
input: transaction_id
time_window:
sliding:
window_duration: 604800s
slide_duration: 86400s
entities:
- name: user_id
timeseries_column:
name: transaction_time
transaction_count_30d:
full_name: ${var.catalog}.${var.schema}.transaction_count_30d
description: Transactions per user over a trailing 30 days
source:
delta_table_source:
full_name: ${var.source_table}
function:
aggregation_function:
count_function:
input: transaction_id
time_window:
sliding:
window_duration: 2592000s
slide_duration: 86400s
entities:
- name: user_id
timeseries_column:
name: transaction_time
materialization_sets:
transactions:
materialized_features:
# Batch offline materialized feature of transaction_count.
- feature_name: ${resources.features.transaction_count.full_name}
offline_store_config:
catalog_name: ${var.catalog}
schema_name: ${var.schema}
table_name_prefix: transactions_offline
cron_schedule_trigger:
mode: DERIVED
# Batch online materialized feature of transaction_count.
- feature_name: ${resources.features.transaction_count.full_name}
online_store_config:
online_store_name: ${var.online_store}
catalog_name: ${var.catalog}
schema_name: ${var.schema}
table_name_prefix: transactions_online
cron_schedule_trigger:
mode: DERIVED
# Batch offline materialized feature of transaction_count_30d.
- feature_name: ${resources.features.transaction_count_30d.full_name}
offline_store_config:
catalog_name: ${var.catalog}
schema_name: ${var.schema}
table_name_prefix: transactions_offline
cron_schedule_trigger:
mode: DERIVED
# Batch online materialized feature of transaction_count_30d.
- feature_name: ${resources.features.transaction_count_30d.full_name}
online_store_config:
online_store_name: ${var.online_store}
catalog_name: ${var.catalog}
schema_name: ${var.schema}
table_name_prefix: transactions_online
cron_schedule_trigger:
mode: DERIVED
Python
Añadir las importaciones a resources/__init__.py:
from databricks.bundles.features import (
AggregationFunction,
CountFunction,
DataSource,
DeltaTableSource,
EntityColumn,
Feature,
Function,
SlidingWindow,
TimeWindow,
TimeseriesColumn,
)
from databricks.bundles.materialization_sets import (
CronSchedule,
CronScheduleMode,
MaterializationSet,
MaterializedFeature,
OfflineStoreConfig,
OnlineStoreConfig,
)
Luego añade esto al cuerpo de load_resources:
resources.add_feature(
'transaction_count',
Feature(
full_name='${var.catalog}.${var.schema}.transaction_count_7d',
description='Transactions per user over a trailing seven days',
source=DataSource(delta_table_source=DeltaTableSource(full_name='${var.source_table}')),
function=Function(
aggregation_function=AggregationFunction(
count_function=CountFunction(input='transaction_id'),
time_window=TimeWindow(
sliding=SlidingWindow(window_duration='604800s', slide_duration='86400s')
),
)
),
entities=[EntityColumn(name='user_id')],
timeseries_column=TimeseriesColumn(name='transaction_time'),
),
)
resources.add_feature(
'transaction_count_30d',
Feature(
full_name='${var.catalog}.${var.schema}.transaction_count_30d',
description='Transactions per user over a trailing 30 days',
source=DataSource(delta_table_source=DeltaTableSource(full_name='${var.source_table}')),
function=Function(
aggregation_function=AggregationFunction(
count_function=CountFunction(input='transaction_id'),
time_window=TimeWindow(
sliding=SlidingWindow(window_duration='2592000s', slide_duration='86400s')
),
)
),
entities=[EntityColumn(name='user_id')],
timeseries_column=TimeseriesColumn(name='transaction_time'),
),
)
resources.add_materialization_set(
'transactions',
MaterializationSet(
materialized_features=[
# Batch offline materialized feature of transaction_count.
MaterializedFeature(
feature_name='${resources.features.transaction_count.full_name}',
offline_store_config=OfflineStoreConfig(
catalog_name='${var.catalog}',
schema_name='${var.schema}',
table_name_prefix='transactions_offline',
),
cron_schedule_trigger=CronSchedule(mode=CronScheduleMode.DERIVED),
),
# Batch online materialized feature of transaction_count.
MaterializedFeature(
feature_name='${resources.features.transaction_count.full_name}',
online_store_config=OnlineStoreConfig(
online_store_name='${var.online_store}',
catalog_name='${var.catalog}',
schema_name='${var.schema}',
table_name_prefix='transactions_online',
),
cron_schedule_trigger=CronSchedule(mode=CronScheduleMode.DERIVED),
),
# Batch offline materialized feature of transaction_count_30d.
MaterializedFeature(
feature_name='${resources.features.transaction_count_30d.full_name}',
offline_store_config=OfflineStoreConfig(
catalog_name='${var.catalog}',
schema_name='${var.schema}',
table_name_prefix='transactions_offline',
),
cron_schedule_trigger=CronSchedule(mode=CronScheduleMode.DERIVED),
),
# Batch online materialized feature of transaction_count_30d.
MaterializedFeature(
feature_name='${resources.features.transaction_count_30d.full_name}',
online_store_config=OnlineStoreConfig(
online_store_name='${var.online_store}',
catalog_name='${var.catalog}',
schema_name='${var.schema}',
table_name_prefix='transactions_online',
),
cron_schedule_trigger=CronSchedule(mode=CronScheduleMode.DERIVED),
),
]
),
)
Paso 4: Añadir una función de streaming
Esta Vista de Características cuenta los eventos por clave durante los últimos 90 minutos y se materializa continuamente en la tienda online. Escribe en un destino, por lo que su conjunto declara un solo miembro.
Un miembro de característica materializada en streaming lleva streaming_mode y no cron_schedule_trigger. Para los modos y lo que significa cada uno, consulta materialization_set.materialized_features.streaming_mode.
Este es un segundo conjunto de materialización en lugar de una característica materializada añadida al conjunto definido en el Paso 3, porque un conjunto de materialización no puede mezclar Vistas de Características materializadas en modo streaming con Vistas de Características materializadas en lote. Una vista de funciones en streaming con una ventana en diente de sierra es la excepción. Sus características materializadas por lotes y streaming pertenecen al mismo conjunto, como en el Paso 5.
La Vista de Características lee un Stream por nombre. Un flujo se crea y versiona por sí solo, fuera del paquete, de la misma manera que la tabla Delta que lee la función por lotes. Para crear uno, consulta Crear un stream.
Una Feature View de streaming interpreta una columna de entrada como una ruta dentro del registro del stream en lugar de como un nombre de columna simple, así que sustituye los nombres que usa el esquema de tu Stream donde los ejemplos muestren value.*.
YAML
Creación de resources/streaming_feature.yml:
resources:
features:
event_count_90m:
full_name: ${var.catalog}.${var.schema}.event_count_90m
description: Events per key over a trailing 90 minutes
source:
stream_source:
full_name: ${var.stream}
function:
aggregation_function:
count_function:
input: value.amount
time_window:
rolling:
window_duration: 5400s
entities:
- name: value.key
timeseries_column:
name: value.event_timestamp
materialization_sets:
events_online:
materialized_features:
- feature_name: ${resources.features.event_count_90m.full_name}
online_store_config:
online_store_name: ${var.online_store}
catalog_name: ${var.catalog}
schema_name: ${var.schema}
table_name_prefix: event_count_90m_online
streaming_mode:
mode: STREAMING_MODE_TYPE_RTM
Python
Añadir RollingWindow y StreamSource a las importaciones de databricks.bundles.features, y StreamingMode y StreamingModeStreamingModeType a las importaciones de databricks.bundles.materialization_sets, y luego añadir esto a load_resources:
resources.add_feature(
'event_count_90m',
Feature(
full_name='${var.catalog}.${var.schema}.event_count_90m',
description='Events per key over a trailing 90 minutes',
source=DataSource(stream_source=StreamSource(full_name='${var.stream}')),
function=Function(
aggregation_function=AggregationFunction(
count_function=CountFunction(input='value.amount'),
time_window=TimeWindow(rolling=RollingWindow(window_duration='5400s')),
)
),
entities=[EntityColumn(name='value.key')],
timeseries_column=TimeseriesColumn(name='value.event_timestamp'),
),
)
resources.add_materialization_set(
'events_online',
MaterializationSet(
materialized_features=[
MaterializedFeature(
feature_name='${resources.features.event_count_90m.full_name}',
online_store_config=OnlineStoreConfig(
online_store_name='${var.online_store}',
catalog_name='${var.catalog}',
schema_name='${var.schema}',
table_name_prefix='event_count_90m_online',
),
streaming_mode=StreamingMode(
mode=StreamingModeStreamingModeType.STREAMING_MODE_TYPE_RTM
),
)
]
),
)
Paso 5: Añadir una feature de streaming con una ventana de dientes de sierra
Materializar una vista de características en streaming cuya agregación utiliza una ventana de dientes de sierra produce tres características materializadas: una característica materializada por lotes offline, una característica materializada por lotes online y una característica materializada en streaming online. El servidor requiere las tres, y se rechaza declarar un subconjunto de las características materializadas. Las dos características materializadas por lotes deben usar DERIVED como cron_schedule_trigger, de modo que Azure Databricks elija la programación de la definición de características. La función de materialización en línea por lotes y la función de materialización en línea en streaming deben compartir la misma configuración de tienda online. Un conjunto de materialización que no cumple estos requisitos es rechazado en el despliegue. Para la lista completa, véase Reglas que debe cumplir un conjunto de materialización.
YAML
Creación de resources/streaming_feature_sawtooth.yml:
resources:
features:
amount_sum:
full_name: ${var.catalog}.${var.schema}.amount_sum_3d
description: Sum of amount per key over a sawtooth window
source:
stream_source:
full_name: ${var.stream}
function:
aggregation_function:
sum:
input: value.amount
time_window:
sawtooth:
window_duration: 259200s
entities:
- name: value.key
timeseries_column:
name: value.event_timestamp
materialization_sets:
amounts:
materialized_features:
# Batch offline materialized feature.
- feature_name: ${resources.features.amount_sum.full_name}
offline_store_config:
catalog_name: ${var.catalog}
schema_name: ${var.schema}
table_name_prefix: amount_sum_offline
cron_schedule_trigger:
mode: DERIVED
# Batch online materialized feature.
- feature_name: ${resources.features.amount_sum.full_name}
online_store_config:
online_store_name: ${var.online_store}
catalog_name: ${var.catalog}
schema_name: ${var.schema}
table_name_prefix: amount_sum_online
cron_schedule_trigger:
mode: DERIVED
# Streaming online materialized feature.
- feature_name: ${resources.features.amount_sum.full_name}
online_store_config:
online_store_name: ${var.online_store}
catalog_name: ${var.catalog}
schema_name: ${var.schema}
table_name_prefix: amount_sum_online
streaming_mode:
mode: STREAMING_MODE_TYPE_RTM
Python
Añadir SawtoothWindow y SumFunction a las importaciones desde databricks.bundles.features, luego añadir esto a load_resources:
resources.add_feature(
'amount_sum',
Feature(
full_name='${var.catalog}.${var.schema}.amount_sum_3d',
description='Sum of amount per key over a sawtooth window',
source=DataSource(stream_source=StreamSource(full_name='${var.stream}')),
function=Function(
aggregation_function=AggregationFunction(
sum=SumFunction(input='value.amount'),
time_window=TimeWindow(sawtooth=SawtoothWindow(window_duration='259200s')),
)
),
entities=[EntityColumn(name='value.key')],
timeseries_column=TimeseriesColumn(name='value.event_timestamp'),
),
)
resources.add_materialization_set(
'amounts',
MaterializationSet(
materialized_features=[
# Batch offline materialized feature.
MaterializedFeature(
feature_name='${resources.features.amount_sum.full_name}',
offline_store_config=OfflineStoreConfig(
catalog_name='${var.catalog}',
schema_name='${var.schema}',
table_name_prefix='amount_sum_offline',
),
cron_schedule_trigger=CronSchedule(mode=CronScheduleMode.DERIVED),
),
# Batch online materialized feature.
MaterializedFeature(
feature_name='${resources.features.amount_sum.full_name}',
online_store_config=OnlineStoreConfig(
online_store_name='${var.online_store}',
catalog_name='${var.catalog}',
schema_name='${var.schema}',
table_name_prefix='amount_sum_online',
),
cron_schedule_trigger=CronSchedule(mode=CronScheduleMode.DERIVED),
),
# Streaming online materialized feature.
MaterializedFeature(
feature_name='${resources.features.amount_sum.full_name}',
online_store_config=OnlineStoreConfig(
online_store_name='${var.online_store}',
catalog_name='${var.catalog}',
schema_name='${var.schema}',
table_name_prefix='amount_sum_online',
),
streaming_mode=StreamingMode(
mode=StreamingModeStreamingModeType.STREAMING_MODE_TYPE_RTM
),
),
]
),
)
Paso 6: Validar y planificar
Comprueba la configuración, que incluye databricks.yml y todos los archivos de recursos que carga el paquete:
databricks bundle validate
validate También es la forma más barata de saber si un campo es aceptado. Nombra cualquier campo que el paquete no reconozca, con su ruta y el archivo y línea de donde proviene:
Warning: unknown field: bogus_field
at resources.features.transaction_count.function.aggregation_function.time_window.sliding
in resources/batch_feature.yml:16:15
Un campo no reconocido se reporta como advertencia y su valor se omite, por lo que lee la salida en lugar de solo el código de salida. Pasa --strict para tratar las advertencias como errores. Para los campos que cada ventana, función y fuente aceptan, véase feature.
Las reglas que aplica el servidor, como la regla de que una Vista de Características con una ventana de dientes de sierra debe declarar las tres características materializadas, no se comprueban aquí y aparecen en databricks bundle deploy.
Luego revisa qué hace el despliegue antes de ejecutarse:
databricks bundle plan
En un primer despliegue, los siete recursos (cuatro Feature Views y tres conjuntos de materialización) informan create:
create features.amount_sum
create features.event_count_90m
create features.transaction_count
create features.transaction_count_30d
create materialization_sets.amounts
create materialization_sets.events_online
create materialization_sets.transactions
Plan: 7 to add, 0 to change, 0 to delete, 0 unchanged
Ejecuta plan también en cada cambio posterior para ver qué acción está planeada.
Paso 7: Desplegar
Despliegue el paquete en el área de trabajo.
databricks bundle deploy
El despliegue informa de cada recurso a medida que lo crea:
Uploading bundle files to /Workspace/Users/someone@example.com/.bundle/feature-store-quickstart/default/files...
Created features.transaction_count_30d
Created features.transaction_count
Created features.amount_sum
Created features.event_count_90m
Created materialization_sets.transactions
Created materialization_sets.events_online
Created materialization_sets.amounts
Files: 4 uploaded, 0 deleted
Resources: 7 created, 0 changed, 0 deleted, 0 unchanged
Paso 8: Comprobar qué se ha creado
databricks bundle summary -o json muestra la configuración de tu paquete con los identificadores de recursos, como el ID del conjunto de materialización, registrados en el último despliegue. Para el conjunto de materialización definido en el Paso 5:
{
"id": "1234567890abcdef1234567890abcdef",
"materialized_features": [
{
"cron_schedule_trigger": {
"mode": "DERIVED"
},
"feature_name": "${resources.features.amount_sum.full_name}",
"offline_store_config": {
"catalog_name": "main",
"schema_name": "features_demo",
"table_name_prefix": "amount_sum_offline"
}
},
{
"cron_schedule_trigger": {
"mode": "DERIVED"
},
"feature_name": "${resources.features.amount_sum.full_name}",
"online_store_config": {
"catalog_name": "main",
"online_store_name": "my_online_store",
"schema_name": "features_demo",
"table_name_prefix": "amount_sum_online"
}
},
{
"feature_name": "${resources.features.amount_sum.full_name}",
"online_store_config": {
"catalog_name": "main",
"online_store_name": "my_online_store",
"schema_name": "features_demo",
"table_name_prefix": "amount_sum_online"
},
"streaming_mode": {
"mode": "STREAMING_MODE_TYPE_RTM"
}
}
]
}
Para ver qué se almacena en el servidor, lee el set de nuevo con el comando Feature Engineering, usando el id de la salida databricks bundle summary:
databricks feature-engineering get-materialization-set <materialization-set-id>
La respuesta contiene lo que el servidor almacenaba para el mismo conjunto, incluyendo los campos que genera:
{
"materialization_set_id": "1234567890abcdef1234567890abcdef",
"materialized_features": [
{
"cron_schedule_trigger": {
"cron_expression": "0 0 2 * * ?",
"mode": "DERIVED",
"timezone_id": "UTC"
},
"feature_name": "main.features_demo.amount_sum_3d",
"is_online": true,
"job_id": 123456789012345,
"materialization_set_id": "1234567890abcdef1234567890abcdef",
"materialized_feature_id": "22222222222222222222222222222222",
"online_store_config": {
"catalog_name": "",
"online_store_name": "my_online_store",
"schema_name": "",
"table_name_prefix": ""
},
"pipeline_schedule_state": "ACTIVE",
"table_name": "main.features_demo.amount_sum_online_ceq88t"
},
{
"feature_name": "main.features_demo.amount_sum_3d",
"is_online": true,
"job_id": 234567890123456,
"materialization_set_id": "1234567890abcdef1234567890abcdef",
"materialized_feature_id": "33333333333333333333333333333333",
"online_store_config": {
"catalog_name": "",
"online_store_name": "my_online_store",
"schema_name": "",
"table_name_prefix": ""
},
"pipeline_id": "12345678-1234-1234-1234-123456789012",
"pipeline_schedule_state": "ACTIVE",
"streaming_mode": {
"mode": "STREAMING_MODE_TYPE_RTM"
},
"table_name": "main.features_demo.amount_sum_online_qiohun"
},
{
"cron_schedule_trigger": {
"cron_expression": "0 0 2 * * ?",
"mode": "DERIVED",
"timezone_id": "UTC"
},
"feature_name": "main.features_demo.amount_sum_3d",
"is_online": false,
"job_id": 123456789012345,
"materialization_set_id": "1234567890abcdef1234567890abcdef",
"materialized_feature_id": "11111111111111111111111111111111",
"pipeline_schedule_state": "ACTIVE",
"table_name": "main.features_demo.amount_sum_offline_ceq88t"
}
]
}
Paso 9: Cambiar la configuración
Los siguientes ejemplos cambian las vistas de características y los conjuntos de materialización respecto a pasos anteriores, y muestran qué hace cada cambio en el despliegue. A menos que un ejemplo nombre un punto de inicio diferente, cada uno comienza desde el despliegue del Paso 7. Cada uno es una edición del archivo que declara el recurso, o del resources mapeo si databricks.yml declaras todo en un solo archivo. En la pestaña de Python, la edición va en resources/__init__.py. Para ver qué cambios se aplican sobre el mismo recurso, cuáles reemplazan el recurso y cuáles se rechazan, véase Cambiar una vista de características y Cambiar un conjunto de materialización.
Eliminación de todas las características materializadas de una Vista de Características
Eliminar cada característica materializada de una Vista de Características de un conjunto de materialización se realiza in situ, de modo que no se recalculan datos de características. Consulte Cambiar un conjunto de materialización.
Lo siguiente toma el conjunto transactions definido en el Paso 3 para Vistas transaction_count de Características y transaction_count_30d, y elimina todas las características materializadas de la Vista transaction_count_30dde Características . Las características materializadas de transaction_count en el mismo conjunto permanecen intactas:
YAML
materialization_sets:
transactions:
materialized_features:
# Batch offline materialized feature of transaction_count.
- feature_name: ${resources.features.transaction_count.full_name}
offline_store_config: # As in Step 3.
cron_schedule_trigger:
mode: DERIVED
# Batch online materialized feature of transaction_count.
- feature_name: ${resources.features.transaction_count.full_name}
online_store_config: # As in Step 3.
cron_schedule_trigger:
mode: DERIVED
- # Batch offline materialized feature of transaction_count_30d.
- - feature_name: ${resources.features.transaction_count_30d.full_name}
- offline_store_config: # As in Step 3.
- cron_schedule_trigger:
- mode: DERIVED
- # Batch online materialized feature of transaction_count_30d.
- - feature_name: ${resources.features.transaction_count_30d.full_name}
- online_store_config: # As in Step 3.
- cron_schedule_trigger:
- mode: DERIVED
Python
resources.add_materialization_set(
'transactions',
MaterializationSet(
materialized_features=[
# Batch offline materialized feature of transaction_count.
MaterializedFeature(...), # As in Step 3.
# Batch online materialized feature of transaction_count.
MaterializedFeature(...), # As in Step 3.
- # Batch offline materialized feature of transaction_count_30d.
- MaterializedFeature(...), # As in Step 3.
- # Batch online materialized feature of transaction_count_30d.
- MaterializedFeature(...), # As in Step 3.
]
),
)
databricks bundle plan marca el conjunto como una actualización:
update materialization_sets.transactions
Plan: 0 to add, 1 to change, 0 to delete, 6 unchanged
Cambiar un campo inmutable de una Feature View
Cuando un conjunto de materialización depende de una Vista de Características, cambiar un campo inmutable de la Vista de Características falla al desplegarse. Reemplazar la Feature View la elimina primero, y la eliminación se rechaza mientras la Feature View tiene features materializadas. Para saber qué campos son inmutables y cuál es la forma recomendada de cambiar uno, véase Cambiar una Feature View.
Lo siguiente toma la Vista transaction_count de Características definida en el Paso 3 y amplía la duración de su ventana deslizante, que es un campo inmutable:
YAML
features:
transaction_count:
# The other keys, as in Step 3.
function:
aggregation_function:
count_function:
input: transaction_id
time_window:
sliding:
- window_duration: 604800s
+ window_duration: 1209600s
slide_duration: 86400s
Python
resources.add_feature(
'transaction_count',
Feature(
# The other arguments, as in Step 3.
function=Function(
aggregation_function=AggregationFunction(
count_function=CountFunction(input='transaction_id'),
time_window=TimeWindow(
- sliding=SlidingWindow(window_duration='604800s', slide_duration='86400s')
+ sliding=SlidingWindow(window_duration='1209600s', slide_duration='86400s')
),
)
),
),
)
databricks bundle plan informa de una recreación:
recreate features.transaction_count
Plan: 1 to add, 0 to change, 1 to delete, 6 unchanged
databricks bundle deploy pide confirmación, y su mensaje explica por qué el cambio no puede llevarse a cabo tal y como está escrito:
This action will result in the deletion or recreation of the following Feature Views.
A Feature View that has materialized features in a materialization set cannot be deleted or
recreated. Remove its materialized features from the set in a separate deploy first, then delete
or recreate the Feature View. Deleting or recreating a Feature View that a FeatureSpec serves is
not blocked, and leaves the FeatureSpec stale:
recreate resources.features.transaction_count
Si lo apruebas, el despliegue falla, porque el conjunto transactions aún conserva las dos características materializadas de la Vista de Características:
Error: cannot recreate resources.features.transaction_count: deleting old id=main.features_demo.transaction_count_7d: Cannot delete feature 'main.features_demo.transaction_count_7d' because it has 2 materialized feature(s). Delete all materialized features first before deleting the feature. (400 BAD_REQUEST)
Para realizar el cambio, despliega dos veces, como se describe en Cambiar una vista de características:
Elimina las características materializadas de la Feature View del conjunto y despliega. El set se actualiza en su lugar, es decir, eliminando todas las características materializadas de una Vista de Características.
Cambiar la Vista de Características, añadir sus características materializadas de nuevo al set y desplegar. El plan recrea la Feature View para la ventana modificada y recrea el conjunto, porque añadir características materializadas a un conjunto lo reemplaza:
Warn: planning resources.materialization_sets.transactions: the member for feature "main.features_demo.transaction_count_7d" is not in the deployed set, and members cannot be added to an existing set, so the whole set will be recreated: every member is dropped and recomputed Warn: planning resources.materialization_sets.transactions: the member for feature "main.features_demo.transaction_count_7d" is not in the deployed set, and members cannot be added to an existing set, so the whole set will be recreated: every member is dropped and recomputed recreate features.transaction_count recreate materialization_sets.transactions Plan: 2 to add, 0 to change, 2 to delete, 5 unchangedDespués de aprobar, el despliegue recrea la Vista de Características y luego el conjunto:
Recreated features.transaction_count Recreated materialization_sets.transactions Files: 3 uploaded, 0 deleted Resources: 2 created, 0 changed, 2 deleted, 5 unchanged
Cambiar un campo inmutable de un conjunto de materialización
Cambiar un campo de cualquier característica materializada en un conjunto reemplaza todo el conjunto de materialización, incluyendo las características materializadas que la edición no toca. Consulte Cambiar un conjunto de materialización.
Lo siguiente toma el conjunto transactions definido en el Paso 3 y cambia el table_name_prefix de su destino en línea, que es inmutable. Ambas características materializadas en línea llevan el prefijo, porque el set tiene un único destino online:
YAML
materialization_sets:
transactions:
materialized_features:
# Batch offline materialized feature of transaction_count.
- feature_name: ${resources.features.transaction_count.full_name}
offline_store_config: # As in Step 3.
cron_schedule_trigger:
mode: DERIVED
# Batch online materialized feature of transaction_count.
- feature_name: ${resources.features.transaction_count.full_name}
online_store_config:
online_store_name: ${var.online_store}
catalog_name: ${var.catalog}
schema_name: ${var.schema}
- table_name_prefix: transactions_online
+ table_name_prefix: transactions_online_v2
cron_schedule_trigger:
mode: DERIVED
# Batch offline materialized feature of transaction_count_30d.
- feature_name: ${resources.features.transaction_count_30d.full_name}
offline_store_config: # As in Step 3.
cron_schedule_trigger:
mode: DERIVED
# Batch online materialized feature of transaction_count_30d.
- feature_name: ${resources.features.transaction_count_30d.full_name}
online_store_config:
online_store_name: ${var.online_store}
catalog_name: ${var.catalog}
schema_name: ${var.schema}
- table_name_prefix: transactions_online
+ table_name_prefix: transactions_online_v2
cron_schedule_trigger:
mode: DERIVED
Python
resources.add_materialization_set(
'transactions',
MaterializationSet(
materialized_features=[
# Batch offline materialized feature of transaction_count.
MaterializedFeature(...), # As in Step 3.
# Batch online materialized feature of transaction_count.
MaterializedFeature(
feature_name='${resources.features.transaction_count.full_name}',
online_store_config=OnlineStoreConfig(
online_store_name='${var.online_store}',
catalog_name='${var.catalog}',
schema_name='${var.schema}',
- table_name_prefix='transactions_online',
+ table_name_prefix='transactions_online_v2',
),
cron_schedule_trigger=CronSchedule(mode=CronScheduleMode.DERIVED),
),
# Batch offline materialized feature of transaction_count_30d.
MaterializedFeature(...), # As in Step 3.
# Batch online materialized feature of transaction_count_30d.
MaterializedFeature(
feature_name='${resources.features.transaction_count_30d.full_name}',
online_store_config=OnlineStoreConfig(
online_store_name='${var.online_store}',
catalog_name='${var.catalog}',
schema_name='${var.schema}',
- table_name_prefix='transactions_online',
+ table_name_prefix='transactions_online_v2',
),
cron_schedule_trigger=CronSchedule(mode=CronScheduleMode.DERIVED),
),
]
),
)
databricks bundle plan informa de una recreación del set, de modo que sus dos características materializadas offline se eliminan y recalculan también:
recreate materialization_sets.transactions
Plan: 1 to add, 0 to change, 1 to delete, 6 unchanged
Añadir características materializadas a un conjunto existente
Añadir una característica materializada a un conjunto de materialización que ya está desplegado reemplaza al conjunto, por lo que cada característica materializada en él se recalcula. Consulte Cambiar un conjunto de materialización.
Lo siguiente toma el conjunto transactions tras la eliminación de todas las características materializadas de la Vista transaction_count_30d de Características en Eliminar todas las características materializadas de una Vista de Características, y añade de nuevo las características materializadas de la Vista transaction_count_30d de Características:
YAML
materialization_sets:
transactions:
materialized_features:
# Batch offline materialized feature of transaction_count.
- feature_name: ${resources.features.transaction_count.full_name}
offline_store_config: # As in Step 3.
cron_schedule_trigger:
mode: DERIVED
# Batch online materialized feature of transaction_count.
- feature_name: ${resources.features.transaction_count.full_name}
online_store_config: # As in Step 3.
cron_schedule_trigger:
mode: DERIVED
+ # Batch offline materialized feature of transaction_count_30d.
+ - feature_name: ${resources.features.transaction_count_30d.full_name}
+ offline_store_config: # As in Step 3.
+ cron_schedule_trigger:
+ mode: DERIVED
+ # Batch online materialized feature of transaction_count_30d.
+ - feature_name: ${resources.features.transaction_count_30d.full_name}
+ online_store_config: # As in Step 3.
+ cron_schedule_trigger:
+ mode: DERIVED
Python
resources.add_materialization_set(
'transactions',
MaterializationSet(
materialized_features=[
# Batch offline materialized feature of transaction_count.
MaterializedFeature(...), # As in Step 3.
# Batch online materialized feature of transaction_count.
MaterializedFeature(...), # As in Step 3.
+ # Batch offline materialized feature of transaction_count_30d.
+ MaterializedFeature(...), # As in Step 3.
+ # Batch online materialized feature of transaction_count_30d.
+ MaterializedFeature(...), # As in Step 3.
]
),
)
databricks bundle plan advierte sobre cada característica materializada añadida y reporta una recreación:
Warn: planning resources.materialization_sets.transactions: the member for feature "main.features_demo.transaction_count_30d" is not in the deployed set, and members cannot be added to an existing set, so the whole set will be recreated: every member is dropped and recomputed
Warn: planning resources.materialization_sets.transactions: the member for feature "main.features_demo.transaction_count_30d" is not in the deployed set, and members cannot be added to an existing set, so the whole set will be recreated: every member is dropped and recomputed
recreate materialization_sets.transactions
Plan: 1 to add, 0 to change, 1 to delete, 6 unchanged
databricks bundle deploy pide confirmación antes de recrear el conjunto:
This action will result in the deletion or recreation of the following materialization sets.
Every materialized feature in a recreated set is dropped and recomputed from scratch, including
the members whose configuration did not change:
recreate resources.materialization_sets.transactions
Eliminación de algunas de las características materializadas de una Vista de Características
No se permite eliminar algunas, pero no todas, de las características materializadas de una Vista de Característica de un conjunto de materialización. Consulte Cambiar un conjunto de materialización.
Lo siguiente toma el conjunto amounts definido en el Paso 5 para la Vista amount_sumde Características, que tiene una ventana de dientes de sierra, y elimina solo su característica materializada offline por lotes:
YAML
materialization_sets:
amounts:
materialized_features:
- # Batch offline materialized feature.
- - feature_name: ${resources.features.amount_sum.full_name}
- offline_store_config: # As in Step 5.
- cron_schedule_trigger:
- mode: DERIVED
# Batch online materialized feature.
- feature_name: ${resources.features.amount_sum.full_name}
online_store_config: # As in Step 5.
cron_schedule_trigger:
mode: DERIVED
# Streaming online materialized feature.
- feature_name: ${resources.features.amount_sum.full_name}
online_store_config: # As in Step 5.
streaming_mode:
mode: STREAMING_MODE_TYPE_RTM
Python
resources.add_materialization_set(
'amounts',
MaterializationSet(
materialized_features=[
- # Batch offline materialized feature.
- MaterializedFeature(...), # As in Step 5.
# Batch online materialized feature.
MaterializedFeature(...), # As in Step 5.
# Streaming online materialized feature.
MaterializedFeature(...), # As in Step 5.
]
),
)
La edición elimina la característica materializada por lotes sin conexión de amount_sum, y esa eliminación también elimina las otras dos características materializadas de la misma Vista de Características, que la edición no solicita. Se rechaza el despliegue:
Error: cannot update resources.materialization_sets.amounts: updating id=1234567890abcdef1234567890abcdef: Deleting materialized features '11111111111111111111111111111111' of feature 'main.features_demo.amount_sum_3d' also deletes materialized features '22222222222222222222222222222222', '33333333333333333333333333333333', which the request does not delete. Delete the unrequested materialized features as well. (400 INVALID_PARAMETER_VALUE)
Paso 10: Limpiar
Las tuberías de materialización siguen funcionando según su calendario configurado hasta que el conjunto se elimina. Desmonta el bundle cuando termines:
databricks bundle destroy
Esto elimina los conjuntos de materialización y las Feature Views declaradas en cada archivo que incluye el paquete. Las tablas, pipelines y trabajos detrás de una característica materializada se eliminan mediante un proceso en segundo plano después de que la última característica materializada que las compartía desaparece, por lo que hay un breve retraso antes de que el coste asociado se detenga. Solo el usuario que creó una función materializada puede eliminarla, así que ejecuta databricks bundle destroy con la misma identidad que desplegó el paquete. Consulte delete_materialized_feature().
Para saber qué costes de materialización y cómo atribuirlos, consulta la gestión de costes de la Feature Store.
Limitations
- Un Stream no es un recurso del bundle. Créalo fuera del paquete y haz referencia a él por nombre.
- Añadir una característica materializada a un conjunto de materialización existente recrea el conjunto, por lo que cada característica materializada en él se recalcula.
- No se puede materializar una Vista de Características en un
request_sourceofeature_view_source, o una que use una funcióncustom_udf. Consulte Materializar vistas de atributos.
Pasos siguientes
- Para desplegar estos recursos desde un flujo de trabajo CI/CD, consulta CI/CD para Feature Views con Acciones de GitHub.
- Para servir estas features desde un paquete, consulte Servir Feature Views usando paquetes de automatización declarativa. Para servirlas con la API de Python, consulte Servir vistas de características y Ejemplo: Desplegar y consultar un endpoint de servicio de funcionalidades.
- Para entrenar un modelo sobre ellos, véase Entrenar modelos con Feature Views.
- Para la referencia completa de configuración, véase feature y materialization_set.
- Para aprender cómo funciona la materialización, consulta Materializar vistas de características.