Gestisci Feature Views utilizzando Declarative Automation Bundles

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

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.

  1. 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 esempio https://adb-1234567890123456.7.azuredatabricks.net.

    databricks auth login --host <workspace-url>
    
  2. Il Databricks CLI richiede di salvare le informazioni immesse come profilo di configurazione di Azure Databricks. Premere Enter per 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 comando databricks auth env --profile <profile-name>.

  3. Nel Web browser completare le istruzioni visualizzate per accedere all'area di lavoro Azure Databricks.

  4. 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 --host e -p per 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:

  1. 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à.

  2. 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 unchanged
    

    Dopo 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_source o feature_view_source, o che utilizza una funzione custom_udf, non può essere materializzata. Vedere Materialize Feature Views.

Passaggi successivi