Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
Importante
Questa funzionalità è in anteprima privata. Per provarlo, contattare il contatto di Azure Databricks.
I Dichiarative Automation Bundles (precedentemente noti come Databricks Asset Bundles) ti permettono di validare, distribuire ed eseguire programmaticamente risorse Azure Databricks come le Feature View e le pipeline che le materializzano. Vedere Che cosa sono i bundle di automazione dichiarativa?.
Questo tutorial crea un pacchetto che dichiara quattro Feature View e le materializza in tre modi: due feature batch scritte sia in uno store offline che in uno online, una feature di streaming scritta continuamente in uno store online e una feature di streaming con finestra a denti di sega, che si materializza in uno store offline e in uno online in modalità batch e in uno store online in modalità streaming. Poi cambi la configurazione, ridistribuisci e smonti tutto.
Dichiarare funzionalità in un bundle ti fornisce le stesse definizioni in ogni workspace su cui implementi, esaminate come sorgente insieme al resto del progetto. È l'alternativa dichiarativa alla chiamata di create_feature e materialize_features da un notebook. Vedere Visualizzazioni delle funzionalità.
Ogni passaggio mostra la configurazione sia in YAML che in Python. Scegli una lingua e la pagina segue la tua scelta.
Requirements
- Databricks CLI versione 1.24.0 o superiore. Eseguire
databricks --versionper verificare. Consulta Installare o aggiornare la CLI di Databricks. - Il motore di distribuzione diretto. Le risorse
featuresematerialization_setsnon sono supportate dal motore di distribuzione Terraform. Vedi Compatibilità delle risorse. - Un'area di lavoro abilitata per il Catalogo di Unity. Vedere Requisiti.
- Permesso per creare funzionalità e materializzarle. Vedere Autorizzazioni.
- Un negozio online esistente. Vedi Creare un negozio online.
- Una tabella Delta esistente con una colonna di entità e una colonna di timestamp, per la materializzazione in batch. Vedere Tabelle di Azure Databricks.
- Uno Stream esistente, per la materializzazione del flusso. Vedi Creare un stream.
Una tabella sorgente e uno Stream hanno ciascuno il proprio ciclo di vita e nessuno dei due è una risorsa di bundle. Creali prima e riferiscili per nome nel bundle, come fa il Passo 3 per la tabella e il Passo 4 per lo Stream.
Risorse Feature Store in un bundle
Questo tutorial dichiara due tipi di risorse del Feature Store e la differenza tra di esse determina quanto costa un deployment.
- Feature View: la definizione di una caratteristica, che ne copre la fonte, l'aggregazione e le sue chiavi. È metadata leggera. Vedi Feature Views e, per il riferimento di configurazione, feature.
- Set di materializzazione: un gruppo di feature materializzate. Una caratteristica materializzata è una Feature View calcolata in una tabella tramite pipeline o job, quindi questa è la componente più onerosa. Raggruppare funzionalità materializzate in un unico insieme indica ad Azure Databricks che possono essere calcolate insieme, quindi le racchiude nel minor numero possibile di tabelle e pipeline Lakeflow che le contengono. Vedi Materialize Feature Views e, per il riferimento di configurazione, materialization_set e materialization_set.materialized_features.
I passaggi che seguono dichiarano funzionalità batch, una funzionalità di streaming e una funzionalità di streaming con finestra a dente di sega. Dichiara solo quelli di cui il tuo progetto ha bisogno. Per informazioni sul funzionamento della materializzazione, vedi Materializzare le Feature Views.
Passaggio 1: Configurare l'autenticazione
Per prima cosa, imposta l'autenticazione tra la CLI Databricks sulla tua macchina di sviluppo e l'area di lavoro Azure Databricks. Questa pagina presuppone che si voglia usare l'autenticazione da utente a computer (U2M) OAuth e un profilo di configurazione di Azure Databricks corrispondente denominato DEFAULT per l'autenticazione.
Annotazioni
L'autenticazione U2M è appropriata per provare questi passaggi in tempo reale. Per i flussi di lavoro completamente automatizzati, Databricks consiglia di usare invece l'autenticazione OAuth da computer a computer (M2M). Consulta le istruzioni di configurazione dell'autenticazione M2M in Autorizzare l'accesso dell'entità di servizio ad Azure Databricks con OAuth.
Usare l'interfaccia della riga di comando di Databricks per avviare la gestione dei token OAuth in locale eseguendo il comando seguente per ogni area di lavoro di destinazione.
Nel comando seguente sostituire
<workspace-url>con l'URL di Azure Databricks per area di lavoro, ad esempiohttps://adb-1234567890123456.7.azuredatabricks.net.databricks auth login --host <workspace-url>Il Databricks CLI richiede di salvare le informazioni immesse come profilo di configurazione di Azure Databricks. Premere
Enterper accettare il nome del profilo suggerito oppure immettere il nome di un profilo nuovo o esistente. Qualsiasi profilo esistente con lo stesso nome viene sovrascritto con le informazioni immesse. È possibile usare i profili per cambiare rapidamente il contesto di autenticazione tra più aree di lavoro.Per ottenere un elenco di tutti i profili esistenti, in un terminale o un prompt dei comandi separato, usare il Databricks CLI per eseguire il comando
databricks auth profiles. Per visualizzare le impostazioni esistenti di un profilo specifico, eseguire il comandodatabricks auth env --profile <profile-name>.Nel Web browser completare le istruzioni visualizzate per accedere all'area di lavoro Azure Databricks.
Per visualizzare il valore corrente del token OAuth di un profilo e il timestamp di scadenza imminente del token, eseguire uno dei comandi seguenti:
databricks auth token --host <workspace-url>databricks auth token -p <profile-name>databricks auth token --host <workspace-url> -p <profile-name>
Se si dispone di più profili con lo stesso valore
--host, potrebbe essere necessario specificare insieme le opzioni--hoste-pper consentire al Databricks CLI di trovare le informazioni corrette corrispondenti sul token OAuth.
Passaggio 2: Creazione del bundle
Crea una directory vuota per il bundle, con un databricks.yml file alla radice e una resources directory accanto ad essa.
YAML
Ognuno dei passaggi seguenti aggiunge un file sotto resources/ per dichiarare le risorse del bundle:
databricks.yml
resources/
batch_feature.yml
streaming_feature.yml
streaming_feature_sawtooth.yml
databricks.yml contiene tre cose:
- Il nome del bundle.
- La voce
include, che indica da quali file il pacchetto carica le proprie risorse. - Le variabili, che contengono valori a cui le risorse possono fare riferimento, come il catalogo, lo schema e i nomi della sorgente.
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
Dichiarare tutto in databricks.yml invece funziona. Ometti include e raccogli le dichiarazioni di ogni passaggio sotto un'unica resources mappatura:
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
Le risorse dichiarate in Python si trovano solo tramite la python mappatura in databricks.yml. Senza di esso il bundle si convalida e viene distribuito con successo ma non contiene risorse, quindi aggiungilo ora:
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 è l'ambiente virtuale in cui la CLI Databricks esegue questo codice. Ogni voce sotto resources nomina una funzione come <module>:<function>, che la CLI Databricks chiama per raccogliere le risorse del bundle. Se viene dichiarata più di una <module>:<function> voce sotto resources, Databricks CLI chiama ogni funzione e raccoglie le risorse restituite da ciascuna.
Quindi crea il progetto e il suo ambiente virtuale, e aggiungi il pacchetto:
uv init --bare
uv venv .venv
uv add databricks-bundles
Crea resources/__init__.py con la funzione che databricks.yml assegna i nomi:
from databricks.bundles.core import Bundle, Resources
def load_resources(bundle: Bundle) -> Resources:
resources = Resources()
# The following steps add resources here.
return resources
Per maggiori informazioni sulla creazione di bundle in Python, incluso il modello di progetto e i mutatori, vedi Configurazione dei bundle in Python.
Passaggio 3: Aggiungi funzionalità batch
Queste due Feature View contano le transazioni per utente nei sette giorni successivi e nei 30 giorni successivi, entrambe ricalcolate quotidianamente, e si materializzano insieme in un negozio offline e uno online.
Una Vista Feature di per sé è solo una definizione. Il set di materializzazione è ciò che ne produce dati.
Ogni risorsa porta due nomi.
transaction_count è la chiave della risorsa: un nome che scegli, univoco all'interno del bundle, che i comandi databricks bundle utilizzano per indirizzare la risorsa e a cui fanno riferimento altri elementi di configurazione. Ad esempio, le due caratteristiche materializzate di transaction_count nel set transactions fanno riferimento al nome della Vista Feature come ${resources.features.transaction_count.full_name}, che indica al bundle che il set dipende dalla Vista transaction_countFeature .
A causa di questa dipendenza, transaction_count viene creato prima dell'insieme transactions quando entrambi vengono creati, e cancellato dopo di esso quando entrambi vengono distrutti. Un nome codificato come main.features_demo.transaction_count_7d, scritto senza ${}, omette tale dipendenza e viene distribuito in un ordine imprevedibile.
full_name è il nome a tre livelli che scegli per la Vista Feature da registrare sotto Unity Catalog e quello che interroghi successivamente. I due nomi sono indipendenti.
Una durata è un conteggio di secondi con un s suffisso, cioè 604800s per sette giorni.
Vedere Specificare una durata per una finestra, sorgente o funzione.
Ogni voce sotto materialized_features è un elemento materializzato: una Vista Feature materializzata verso una destinazione. Ognuna di queste Feature View si materializza sia in una destinazione offline che online, quindi ognuna contribuisce con due elementi materializzati e ciascun membro porta con sé il proprio trigger. Entrambe le Feature View scrivono sulla stessa destinazione offline e online, perché un set ha una destinazione offline e al massimo una destinazione online.
YAML
Creare 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
Aggiungi le importazioni 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,
)
Poi aggiungi questo al corpo di 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),
),
]
),
)
Passo 4: Aggiungi una feature di streaming
Questa Feature View conta gli eventi per chiave nell'arco di 90 minuti e si materializza continuamente sullo store online. Scrive in una sola destinazione, quindi il suo set dichiara un singolo membro.
Un membro di feature materializzata in streaming contiene streaming_mode e nessun cron_schedule_trigger. Per le modalità e cosa significa ciascuna, consulta materialization_set.materialized_features.streaming_mode.
Questo è un secondo set di materializzazione piuttosto che una feature materializzata aggiunta al set definito nel Passo 3, perché un set di materializzazione non può mescolare le Feature Views materializzate in modalità streaming con le Feature Views materializzate in batch. Una Feature View in streaming con finestra a dente di sega è l'eccezione. Le sue feature materializzate per batch e streaming appartengono allo stesso set, come nel Passo 5.
La Vista Feature legge un Stream per nome. Uno Stream viene creato e versionato autonomamente, al di fuori del bundle, nello stesso modo della tabella Delta che la funzionalità batch legge. Per crearne uno, vedi Crea un stream.
Una Feature View in streaming fa riferimento a una colonna di input come a un percorso all'interno del record del flusso invece che come a un semplice nome di colonna, quindi sostituisci i nomi usati dallo schema del tuo Flusso ovunque gli esempi mostrino value.*.
YAML
Creare 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
Aggiungi RollingWindow e StreamSource alle importazioni da databricks.bundles.features, e StreamingMode e StreamingModeStreamingModeType alle importazioni da databricks.bundles.materialization_sets, quindi aggiungi questo 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
),
)
]
),
)
Passaggio 5: Aggiungi una feature di streaming con una finestra a dente di sega
La materializzazione di una Feature View in streaming la cui aggregazione utilizza una finestra a dente di sega produce tre feature materializzate: una feature materializzata batch offline, una feature materializzata batch online e una feature materializzata di streaming online. Il server richiede tutte e tre le cose e la dichiarazione di un sottoinsieme delle feature materializzate viene rifiutata. Le due funzionalità materializzate in batch devono usare DERIVED come cron_schedule_trigger, in modo che Azure Databricks scelga la pianificazione dalla definizione della funzionalità. La funzione batch online materialized e la funzione streaming online materialized devono condividere la stessa configurazione dello store online. Un set di materializzazione che non soddisfa questi requisiti viene rifiutato al momento del deployment. Per l'elenco completo, vedi Regole che un insieme di materializzazione deve soddisfare.
YAML
Creare 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
Aggiungi SawtoothWindow e SumFunction alle importazioni da databricks.bundles.features, quindi aggiungi questo 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
),
),
]
),
)
Passaggio 6: Valida e pianifica
Controlla la configurazione, ovvero databricks.yml, e ogni file di risorsa caricato dal bundle:
databricks bundle validate
validate è anche il modo più economico per scoprire se un campo è accettato. Nomina qualsiasi campo che il bundle non riconosce, con il suo percorso e il file e la riga da cui 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 non riconosciuto viene segnalato come un avviso e il suo valore viene eliminato, quindi leggi l'output e non solo il codice di uscita. Usa --strict per considerare gli avvisi come errori. Per i campi accettati da ogni finestra, funzione e sorgente, vedi feature.
Le regole applicate dal server, come la regola secondo cui una Feature View con una finestra a sega deve dichiarare tutte e tre le funzionalità materializzate, non vengono selezionate qui e si presentano su databricks bundle deploy.
Poi ripassa cosa fa la distribuzione prima di essere eseguita:
databricks bundle plan
Alla prima implementazione, tutte e sette le risorse (quattro Feature View e tre set di materializzazione) riportano 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
Esegui plan anche a ogni cambiamento successivo, per vedere quali azioni sono pianificate.
Passaggio 7: Distribuisci
Distribuire il bundle nell'area di lavoro:
databricks bundle deploy
Il deployment segnala ogni risorsa man mano che la 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
Passaggio 8: Controlla cosa viene creato
databricks bundle summary -o json riporta la configurazione del tuo bundle con gli identificatori delle risorse, come l'ID del set di materializzazione, registrati all'ultimo deployment. Per il set di materializzazione definito nel Passaggio 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"
}
}
]
}
Per vedere cosa è memorizzato sul server, recupera il set con il comando Feature Engineering, utilizzando il id dall'output di databricks bundle summary:
databricks feature-engineering get-materialization-set <materialization-set-id>
La risposta contiene ciò che il server ha memorizzato per lo stesso set, inclusi i campi che 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"
}
]
}
Passaggio 9: Modifica la configurazione
Gli esempi seguenti modificano le Feature View e i set di materializzazione rispetto ai passaggi precedenti e mostrano cosa fa ciascuna modifica durante il deployment. A meno che un esempio non indichi un punto di partenza diverso, ciascuno di essi inizia dal deployment del Passo 7. Ognuno è una modifica al file che dichiara la risorsa, o alla resources mappatura se databricks.yml hai dichiarato tutto in un unico file. Nella scheda Python, la modifica va in resources/__init__.py. Per sapere quali modifiche vengono applicate direttamente, quali sostituiscono la risorsa e quali vengono rifiutate, vedi Modifica di una Feature View e Modifica di un set di materializzazione.
Rimuovere tutte le funzionalità materializzate di una Feature View
La rimozione di ogni feature materializzata di una Vista Feature da un set di materializzazione viene applicata sul posto, quindi nessun dato di feature viene ricalcolato. Vedi Modifica di un set di materializzazione.
Quanto segue prende l'insieme transactions definito nel Passaggio 3 per le Feature View transaction_count e transaction_count_30d, e rimuove ogni feature materializzata della Feature View transaction_count_30d. Le caratteristiche materializzate nello stesso set transaction_count restano inalterate:
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 Riporta il set come aggiornamento:
update materialization_sets.transactions
Plan: 0 to add, 1 to change, 0 to delete, 6 unchanged
Modificare un campo immutabile di una Feature View
Quando un set di materializzazione dipende da una Feature View, la modifica di un campo immutabile della Feature View non riesce al momento del deployment. Sostituire la Vista Feature la elimina viene prima eliminata, e la cancellazione viene rifiutata mentre la Vista Feature ha feature materializzate. Per sapere quali campi sono immutabili e per il modo consigliato di modificarne uno, vedi Modifica di una vista Feature.
Di seguito prende la Vista transaction_count Feature definita nel Passaggio 3 e ne amplia la durata della finestra scorrevole, che è un campo immutabile:
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 Segnala una ricreazione:
recreate features.transaction_count
Plan: 1 to add, 0 to change, 1 to delete, 6 unchanged
databricks bundle deploy chiede una conferma, e il suo messaggio spiega perché il cambiamento non può andare avanti così come scritto:
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
Se approvi, il deployment fallisce, perché il set transactions contiene ancora le due funzionalità materializzate della Feature View:
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)
Per effettuare la modifica, esegui il deployment due volte, come descritto in Changing a Feature View:
Rimuovi le funzionalità materializzate della Vista Feature dal set e distribuisci. Il set viene aggiornato sul posto, come in Rimozione di tutte le funzionalità materializzate di una vista delle funzionalità.
Modifica la Feature View, aggiungi nuovamente le sue caratteristiche materializzate al set e distribuisci. Il piano ricrea la Vista Feature per la finestra modificata e ricrea l'insieme, perché aggiungere elementi materializzati a un set lo sostituisce:
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 unchangedDopo aver approvato, la distribuzione ricrea la Feature View e poi il set:
Recreated features.transaction_count Recreated materialization_sets.transactions Files: 3 uploaded, 0 deleted Resources: 2 created, 0 changed, 2 deleted, 5 unchanged
Modificare un campo immutabile di un insieme di materializzazione
Modificare un campo di qualsiasi elemento materializzato in un insieme sostituisce l'intero set di materializzazione, inclusi gli elementi materializzati che la modifica non tocca. Vedi Modifica di un set di materializzazione.
Quanto segue prende l'insieme transactions definito nel Passo 3 e modifica quello table_name_prefix della sua destinazione online, che è immutabile. Entrambe le funzionalità materializzate online portano il prefisso, perché il set ha una sola destinazione 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 segnala la ricreazione del set, così che le sue due funzionalità materializzate offline in lotto vengano eliminate e ricalcolate:
recreate materialization_sets.transactions
Plan: 1 to add, 0 to change, 1 to delete, 6 unchanged
Aggiungere caratteristiche materializzate a un set esistente
Aggiungere una caratteristica materializzata a un set di materializzazione già implementato sostituisce il sett, quindi ogni caratteristica materializzata in esso viene ricalcolata. Vedi Modifica di un set di materializzazione.
Quanto segue riprende l'insieme transactions dopo la rimozione di ogni caratteristica materializzata della Vista transaction_count_30d Feature in Rimozione di tutte le caratteristiche materializzate di una Vista Feature e aggiunge di nuovo le caratteristiche materializzate della Vista transaction_count_30d Feature:
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 avverte di ogni funzione materializzata aggiunta e segnala una ricreazione:
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 chiede conferma prima di ricreare il set:
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
Rimuovere alcune delle funzionalità materializzate di una Feature View
La rimozione di alcune ma non tutte le caratteristiche materializzate di una vista Feature da un set di materializzazione viene rifiutata. Vedi Modifica di un set di materializzazione.
Quanto segue prende il set amounts definito nel Passo 5 per la Feature View amount_sum, che ha una finestra a dente di sega, e rimuove solo la sua feature materializzata offline in batch:
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 modifica rimuove la funzionalità materializzata offline batch di amount_sum, e tale eliminazione elimina anche le altre due funzionalità materializzate della stessa Vista Feature, cosa che la modifica non richiede. Il deployment è rifiutato:
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)
Passo 10: Pulisci
Le pipeline di materializzazione continuano a funzionare secondo il loro calendario configurato fino a quando l'insieme non viene eliminato. Smonta il bundle quando hai finito:
databricks bundle destroy
Questo elimina i set di materializzazione e le Feature View dichiarate in ogni file incluso dal bundle. Le tabelle, le pipeline e i job dietro una funzionalità materializzata vengono rimossi da un processo in background dopo che l'ultima funzionalità materializzata che li condivideva è scomparsa, quindi c'è un breve ritardo prima che il costo associato si interrompa. Solo l'utente che ha creato una funzionalità materializzata può eliminarla, quindi eseguila databricks bundle destroy con la stessa identità che ha distribuito il bundle. Vedete delete_materialized_feature().
Per quali costi di materializzazione e come attribuirli, vedi Gestione dei costi del Feature Store.
Limitations
- Uno stream non è una risorsa del bundle. Crealo al di fuori del bundle e riferiscilo per nome.
- Aggiungere una feature materializzata a un insieme di materializzazione esistente ricrea l'insieme, quindi ogni feature materializzata al suo interno viene ricalcolata.
- Una vista Feature su un
request_sourceofeature_view_source, o che utilizza una funzionecustom_udf, non può essere materializzata. Vedere Materialize Feature Views.
Passaggi successivi
- Per distribuire queste risorse da un flusso di lavoro CI/CD, vedi CI/CD per le Feature Views con GitHub Actions.
- Per servire queste funzionalità da un bundle, vedi Serve Feature Views usando Declarative Automation Bundles. Per servirli con l'API Python, vedi Serve Feature Views ed Esempio: Distribuisci e consulta un endpoint di servizio di funzionalità.
- Per addestrare un modello su di essi, consulta Allenare modelli con Feature View.
- Per il riferimento completo alla configurazione, vedi feature e materialization_set.
- Per capire come funziona la materializzazione, vedi Materializzare le Feature Views.