Zarządzaj Feature Views za pomocą Declarative Automation Bundles

Important

Ta funkcja jest dostępna w prywatnej wersji zapoznawczej. Aby ją wypróbować, skontaktuj się z osobą kontaktową usługi Azure Databricks.

Deklaratywne pakiety automatyzacji (dawniej znane jako Databricks Asset Bundles) umożliwiają programowe sprawdzanie poprawności, wdrażanie i uruchamianie zasobów Azure Databricks, takich jak widoki cech oraz potoki, które je materializują. Zobacz Co to są pakiety automatyzacji deklaratywnej?.

Ten samouczek tworzy pakiet, który deklaruje cztery Feature Views i materializuje je na trzy sposoby: dwie funkcje wsadowe zapisywane zarówno do sklepu offline, jak i online, funkcję strumieniową zapisywaną w sposób ciągły do sklepu online oraz funkcję strumieniową z oknem piłozębnym, która jest materializowana do sklepu offline i online w trybie wsadowym oraz do sklepu online w trybie strumieniowym. Następnie zmieniasz konfigurację, ponownie wdrażasz i usuwasz wszystko.

Deklarowanie feature’ów w bundlu daje ci te same definicje w każdym workspace, do którego wdrażasz, i są one przeglądane w postaci kodu źródłowego wraz z resztą projektu. Jest to deklaratywna alternatywa dla wywoływania create_feature i materialize_features w notatniku. Zobacz Widoki funkcji.

Każdy krok pokazuje konfigurację zarówno w YAML, jak i Python. Wybierz język, a strona dostosuje się do twojego wyboru.

Requirements

Tabela źródłowa i strumień mają każdy swój własny cykl życia i żaden z nich nie jest zasobem pakietowym. Najpierw utwórz je i odwołuj się do nich po nazwie w zestawie, tak jak krok 3 dla tabeli i Krok 4 dla strumienia.

Zasoby Feature Store w pakiecie

Ten samouczek deklaruje dwa typy zasobów Feature Store, a różnica między nimi decyduje o kosztach wdrożenia.

  • Feature View: definicja cechy, obejmująca jej źródło, agregację oraz klucze. To lekkie metadane. Zobacz Widoki Cech, a odnośnie konfiguracji — cecha.
  • Zestaw materializacji: grupa zmaterializowanych cech. Zmaterializowana cecha to jeden widok cech obliczony do tabeli przez pipeline lub zlecenia, więc to jest ta bardziej zasobożerna połowa. Grupowanie zmaterializowanych cech w jednym zestawie informuje Azure Databricks, że można je obliczyć razem, więc pakuje je do jak najmniejszej liczby tabel i potoków Lakeflow, które je przechowywają. Zobacz Materialize Feature Views, a odniesienie konfiguracji materialization_set i materialization_set.materialized_features.

Kolejne kroki deklarują funkcje wsadowe, funkcję streamingu oraz funkcję streamingu z oknem piłozębnym. Deklaruj tylko te, których potrzebuje Twój projekt. Aby dowiedzieć się, jak działa materializacja, zobacz Materialize Feature Views.

Krok 1. Konfigurowanie uwierzytelniania

Najpierw skonfiguruj uwierzytelnianie między narzędziem Databricks CLI na komputerze deweloperskim a obszarem roboczym Azure Databricks. Na tej stronie założono, że chcesz użyć uwierzytelniania użytkownika do komputera (U2M) OAuth i odpowiedniego profilu konfiguracji usługi Azure Databricks o nazwie DEFAULT na potrzeby uwierzytelniania.

Note

Uwierzytelnianie U2M jest odpowiednie do wypróbowania tych kroków w czasie rzeczywistym. W przypadku w pełni zautomatyzowanych przepływów pracy usługa Databricks zaleca zamiast tego użycie uwierzytelniania maszynowego do maszyny OAuth (M2M). Zobacz instrukcje dotyczące konfigurowania uwierzytelniania M2M w temacie Autoryzowanie dostępu jednostki usługi do usługi Azure Databricks przy użyciu protokołu OAuth.

  1. Użyj Databricks CLI, aby lokalnie zainicjować zarządzanie tokenami OAuth, uruchamiając następujące polecenie dla każdego docelowego obszaru roboczego.

    W poniższym poleceniu zastąp ciąg <workspace-url> adresem URL usługi Azure Databricks dla obszaru roboczego, na przykład https://adb-1234567890123456.7.azuredatabricks.net.

    databricks auth login --host <workspace-url>
    
  2. Interfejs wiersza polecenia usługi Databricks poprosi Cię o zapisanie wprowadzonych informacji jako profil konfiguracji usługi Azure Databricks. Naciśnij Enter , aby zaakceptować sugerowaną nazwę profilu lub wprowadź nazwę nowego lub istniejącego profilu. Każdy istniejący profil o tej samej nazwie zostanie zastąpiony wprowadzonymi informacjami. Profile umożliwiają szybkie przełączanie kontekstu uwierzytelniania między wieloma obszarami roboczymi.

    Aby uzyskać listę wszystkich istniejących profilów, w osobnym terminalu lub wierszu polecenia użyj interfejsu wiersza polecenia usługi Databricks, aby uruchomić polecenie databricks auth profiles. Aby wyświetlić istniejące ustawienia określonego profilu, uruchom polecenie databricks auth env --profile <profile-name>.

  3. W przeglądarce internetowej wykonaj instrukcje na ekranie, aby zalogować się do obszaru roboczego usługi Azure Databricks.

  4. Aby wyświetlić bieżącą wartość tokenu OAuth profilu i zbliżający się znacznik czasu wygaśnięcia tokenu, uruchom jedno z następujących poleceń:

    • databricks auth token --host <workspace-url>
    • databricks auth token -p <profile-name>
    • databricks auth token --host <workspace-url> -p <profile-name>

    Jeśli masz wiele profilów o tej samej wartości --host, może być konieczne jednoczesne określenie opcji --host i -p, aby pomóc interfejsowi CLI usługi Databricks w znalezieniu prawidłowych informacji pasujących do tokenu OAuth.

Krok 2. Tworzenie pakietu

Stwórz pusty katalog dla pakietu, z plikiem databricks.yml w jego korzeniu i katalogiem resources obok.

YAML

Każdy z poniższych kroków dodaje jeden plik pod resources/, aby zadeklarować zasoby pakietu:

databricks.yml
resources/
  batch_feature.yml
  streaming_feature.yml
  streaming_feature_sawtooth.yml

databricks.yml zawiera trzy rzeczy:

  • Nazwa pakietu.
  • Wpis include , który decyduje, z których plików pakiet ładuje swoje zasoby.
  • Zmienne, które zawierają wartości, do których zasoby mogą się odwoływać, takie jak katalog, schemat i nazwy źródeł.
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

Deklarowanie wszystkiego w databricks.yml miejscu też działa. Pomiń include i zbierz deklaracje każdego kroku pod jednym resources odwzorowaniem:

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

Zasoby zadeklarowane w Pythonie są dostępne tylko poprzez mapowanie python w databricks.yml. Bez niego pakiet waliduje i wdraża się pomyślnie, ale nie zawiera zasobów, więc dodaj go teraz:

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 to środowisko wirtualne, w którym Databricks CLI uruchamia ten kod. Każdy wpis pod resources określa funkcję jako <module>:<function>, którą Databricks CLI wywołuje, aby zebrać zasoby pakietu. Jeśli pod resources zadeklarowano więcej niż jeden wpis <module>:<function>, Databricks CLI wywołuje każdą funkcję i zbiera zasoby, które każda z nich zwraca.

Następnie stwórz projekt i jego środowisko wirtualne, a następnie dodaj pakiet:

uv init --bare
uv venv .venv
uv add databricks-bundles

Utwórz resources/__init__.py z funkcją, której nazwę określa databricks.yml:

from databricks.bundles.core import Bundle, Resources


def load_resources(bundle: Bundle) -> Resources:
    resources = Resources()
    # The following steps add resources here.
    return resources

Więcej informacji o tworzeniu pakietów w Pythonie, w tym szablonu projektu i mutatorów, znajdziesz w artykule Konfiguracja pakietu w Pythonie.

Krok 3: Dodaj funkcje wsadowe

Te dwa widoki funkcji liczą transakcje na użytkownika z ostatnich 7 dni i ostatnich 30 dni, oba przetwarzane codziennie, i są razem materializowane do magazynu offline i online.

Widok Feature View sam w sobie jest tylko definicją. Zbiór materializacji to to, co generuje z niego dane.

Każdy zasób nosi dwie nazwy. transaction_count jest kluczem zasobu: nazwą, którą wybierasz, unikalną w pakiecie, której polecenia databricks bundle używają do adresowania zasobu i do której odwołują się inne elementy konfiguracji. Na przykład dwie zmaterializowane cechy transaction_count w zbiorze transactions odnoszą się do nazwy Feature View jako ${resources.features.transaction_count.full_name}, co mówi wiązce, że zbiór zależy od Feature View transaction_count.

Z powodu tej zależności tworzy się transaction_count przed zbiorem transactions , gdy oba są tworzone, a usuwane po nim, gdy oba zostaną zniszczone. Twardokodowana nazwa taka jak main.features_demo.transaction_count_7d, zapisana bez ${}, pomija tę zależność i powoduje wdrażanie w nieprzewidywalnej kolejności.

full_name to trzypoziomowa nazwa, którą wybierasz, pod którą rejestrowany jest Widok Funkcji w Unity Catalog, i której później używasz w zapytaniach. Obie nazwy są niezależne.

Czas trwania to liczba sekund z przyrostkiem s, na przykład 604800s dla siedmiu dni. Zobacz Określanie czasu trwania okna, źródła lub funkcji.

Każdy wpis poniżej materialized_features to jeden zmaterializowany element cechy: jeden Feature View zmaterializowany w jednym miejscu docelowym. Każdy z tych widoków funkcji materializuje się zarówno do lokalizacji offline, jak i online, więc każdy z nich dostarcza dwa zmaterializowane elementy funkcji, a każdy członek ma własny wyzwalacz. Oba Feature Views zapisują do tej samej lokalizacji docelowej offline i online, ponieważ zestaw ma jedną lokalizację docelową offline i co najwyżej jedną lokalizację docelową online.

YAML

Utwórz 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

Dodaj importy do 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,
)

Następnie dodaj to do ciała 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),
            ),
        ]
    ),
)

Krok 4: Dodaj funkcję streamingu

Ten Feature View liczy zdarzenia na klucz przez kolejne 90 minut i jest stale materializowany w sklepie online. Zapisuje do jednego miejsca, więc jego zbiór deklaruje pojedynczego członka.

Element streamingowej cechy materializowanej zawiera streaming_mode i nie zawiera cron_schedule_trigger. Aby poznać tryby i znaczenie każdego z nich, zobacz materialization_set.materialized_features.streaming_mode.

Jest to drugi zestaw materializacji, a nie zmaterializowana cecha dodana do zestawu zdefiniowanego w kroku 3, ponieważ zestaw materializacji nie może mieszać widoków cech materializowanych w trybie strumieniowym z widokami cech materializowanych w partii. Wyjątkiem jest widok Feature View z oknem typu sawtooth. Jego materializowane funkcje wsadowe i strumieniowe należą do tego samego zestawu, jak w Step 5.

Widok Feature Viewa odczytuje strumień według nazwy. Strumień jest tworzony i wersjonowany samodzielnie, poza bundem, tak jak tabela Delta, którą odczytuje cecha wsadowa. Aby go utworzyć, zobacz Stwórz strumień.

Streaming Feature View traktuje kolumnę wejściową jako ścieżkę w rekordzie strumienia, a nie jako zwykłą nazwę kolumny, więc zastąp nazwami używanymi w schemacie Twojego strumienia miejsca, w których w przykładach widnieje value.*.

YAML

Utwórz 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

Dodaj RollingWindow i StreamSource do importów z databricks.bundles.features, oraz StreamingMode i StreamingModeStreamingModeType do importów z databricks.bundles.materialization_sets, a następnie dodaj to do 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
                ),
            )
        ]
    ),
)

Krok 5: Dodaj cechę strumieniową z oknem piłozębnym

Materializacja strumieniowego widoku cech, którego agregacja wykorzystuje okno piłozębne, generuje trzy zmaterializowane cechy: zmaterializowaną cechę wsadową offline, zmaterializowaną cechę wsadową online oraz zmaterializowaną cechę strumieniową online. Serwer wymaga wszystkich trzech, a deklarowanie podzbioru zmaterializowanych cech jest odrzucane. Dwie wsadowe funkcje materializowane muszą używać DERIVED jako cron_schedule_trigger, tak aby Azure Databricks wybierał harmonogram z definicji cechy. Funkcja wsadowa zmaterializowana online oraz funkcja strumieniowa zmaterializowana online muszą korzystać z tej samej konfiguracji sklepu online. Zestaw materializacji, który nie spełnia tych wymagań, jest odrzucany podczas wdrożenia. Pełną listę można znaleźć w Regułach, które musi spełniać zbiór materializacji.

YAML

Utwórz 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

Dodaj SawtoothWindow i SumFunction do importów z databricks.bundles.features, a następnie dodaj to do 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
                ),
            ),
        ]
    ),
)

Krok 6: Zwaliduj i zaplanuj

Sprawdź konfigurację, która odczytuje databricks.yml, oraz każdy plik zasobów, który ładuje pakiet:

databricks bundle validate

validate To także najtańszy sposób, by dowiedzieć się, czy dane pole jest akceptowane. Wymienia każde pole, którego pakiet nie rozpoznaje, wraz z jego ścieżką oraz plikiem i linią, z której pochodzi:

Warning: unknown field: bogus_field
  at resources.features.transaction_count.function.aggregation_function.time_window.sliding
  in resources/batch_feature.yml:16:15

Nierozpoznane pole jest zgłaszane jako ostrzeżenie i jego wartość jest pomijana, więc odczytuj wyjście, a nie tylko kod wyjścia. Przekaż --strict, aby traktować ostrzeżenia jako błędy. Pola akceptowane przez każde okno, funkcję i źródło znajdziesz w feature.

Reguły egzekwowane przez serwer, takie jak zasada, że widok cech z oknem piłowatym musi deklarować wszystkie trzy zmaterializowane cechy, nie są tu sprawdzane i pojawiają się w databricks bundle deploy.

Następnie przejrzyj, co robi wdrożenie przed uruchomieniem:

databricks bundle plan

Podczas pierwszego wdrożenia wszystkie siedem zasobów (cztery widoki cech i trzy zestawy materializacji) raportują 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

Uruchamiaj plan przy każdej kolejnej zmianie, aby też zobaczyć, jakie działania są planowane.

Krok 7: Wdrożenie

Wdróż pakiet w obszarze roboczym:

databricks bundle deploy

Wdrożenie raportuje każdy zasób w momencie jego tworzenia:

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

Krok 8: Sprawdź, co jest tworzone

databricks bundle summary -o json raportuje konfigurację pakietu wraz z identyfikatorami zasobów, takimi jak identyfikator zestawu materializacji, zarejestrowanymi przy ostatnim wdrożeniu. Dla zbioru materializacji zdefiniowanego w kroku 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"
      }
    }
  ]
}

Aby zobaczyć, co jest zapisane na serwerze, odczytaj ten zestaw z powrotem za pomocą polecenia Feature Engineering, używając elementu id z danych wyjściowych databricks bundle summary:

databricks feature-engineering get-materialization-set <materialization-set-id>

Odpowiedź zawiera to, co serwer zapisał dla tego samego zbioru, włącznie z polami, które generuje:

{
  "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"
    }
  ]
}

Krok 9: Zmień konfigurację

Poniższe przykłady zmieniają Feature Views i zestawy materializacji z wcześniejszych kroków oraz pokazują, co każda zmiana robi podczas wdrożenia. O ile przykład nie wskazuje innego punktu wyjścia, każdy zaczyna się od wdrożenia w kroku 7. Każda z nich to edycja pliku, który deklaruje zasób, lub mapowania resources w databricks.yml, jeśli wszystko zadeklarowałeś w jednym pliku. W zakładce Python edycję wprowadza się w resources/__init__.py. Aby zobaczyć, które zmiany są wprowadzane na miejscu, które zastępują zasób, a które są odrzucane, zobacz Zmienianie widoku cech oraz Zmienianie zbioru materializacji.

Usunięcie wszystkich zmaterializowanych cech Feature View

Usunięcie każdej zmaterializowanej cechy jednego widoku cech z zestawu materializacji jest stosowane na miejscu, więc dane cech nie są ponownie obliczane. Zobacz Zmiana zbioru materializacji.

Poniższy przykład wykorzystuje zbiór transactions zdefiniowany w kroku 3 dla widoków cech transaction_count i transaction_count_30d oraz usuwa każdą zmaterializowaną cechę widoku cech transaction_count_30d. Cechy materializowane transaction_count w tym samym zbiorze pozostają niezmienione:

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 traktuje zbiór jako aktualizację:

update materialization_sets.transactions

Plan: 0 to add, 1 to change, 0 to delete, 6 unchanged

Zmiana niezmiennego pola Feature View

Gdy zbiór materializacji zależy od Feature View, zmiana niezmiennego pola Feature View kończy się niepowodzeniem podczas wdrożenia. Zastąpienie widoku funkcji usuwa go jako pierwszego, a usunięcie zostaje odrzucone, gdy widok funkcji ma zmaterializowane cechy. Aby zobaczyć, które pola są niezmienne, oraz zalecany sposób zmiany jednego z nich, zobacz Changing a Feature View.

Poniższy przykład wykorzystuje widok cech transaction_count zdefiniowany w kroku 3 i rozszerza czas trwania jego okna przesuwnego, które jest polem niezmiennym:

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 zgłasza ponowne utworzenie:

recreate features.transaction_count

Plan: 1 to add, 0 to change, 1 to delete, 6 unchanged

databricks bundle deploy prosi o potwierdzenie, a jego komunikat wyjaśnia, dlaczego zmiana nie może zostać wprowadzona w obecnej postaci:

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

Jeśli zatwierdzisz, wdrożenie się nie powiedzie, ponieważ zestaw transactions nadal zawiera dwie zmaterializowane cechy 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)

Aby wprowadzić zmianę, wdroż ją dwukrotnie, zgodnie z opisem w Zmienianie widoku cech:

  1. Usuń zmaterializowane cechy widoku funkcji z zestawu i wdroż. Zestaw jest aktualizowany na miejscu, jak w Usuwanie wszystkich zmaterializowanych cech widoku cech.

  2. Zmień Feature View, dodaj jego materializowane cechy z powrotem do zestawu i wdroż. Plan odtwarza Widok Cech dla zmienionego okna i odtwarza cały zestaw, ponieważ dodanie zmaterializowanych cech do zestawu zastępuje je:

    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
    

    Po zatwierdzeniu wdrożenie odtwarza Feature View i następnie zestaw:

    Recreated features.transaction_count
    Recreated materialization_sets.transactions
    Files: 3 uploaded, 0 deleted
    Resources: 2 created, 0 changed, 2 deleted, 5 unchanged
    

Zmiana niezmiennego pola zestawu materializacji

Zmiana pola dowolnej zmaterializowanej cechy w zbiorze zastępuje cały zbiór materializacji, włącznie z tymi zmaterializowanymi cechami, których edycja nie dotyka. Zobacz Zmiana zbioru materializacji.

Poniżej opisano, jak wziąć zbiór transactions zdefiniowany w kroku 3 i zmienić table_name_prefix jego miejsca docelowego online, które jest niezmienne. Obie zmaterializowane cechy online mają ten prefiks, ponieważ zestaw ma jedno miejsce docelowe 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 zgłasza ponowne utworzenie zestawu, więc jego dwie zmaterializowane cechy offline przetwarzane wsadowo są również usuwane i ponownie obliczane:

recreate materialization_sets.transactions

Plan: 1 to add, 0 to change, 1 to delete, 6 unchanged

Dodawanie zmaterializowanych cech do istniejącego zestawu

Dodanie zmaterializowanej cechy do już wdrożonego zbioru materializacyjnego zastępuje ten zbiór, więc każda zmaterializowana cecha w nim jest ponownie obliczana. Zobacz Zmiana zbioru materializacji.

Poniższy przykład przedstawia zestaw transactions po usunięciu wszystkich zmaterializowanych cech Feature View transaction_count_30d w Usuwanie wszystkich zmaterializowanych cech obiektu Feature View i dodaje z powrotem zmaterializowane cechy Feature View transaction_count_30d:

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 Ostrzega przed każdą dodaną zmaterializowaną funkcją i zgłasza ponowne utworzenie:

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 Pyta o potwierdzenie przed ponownym utworzeniem zbioru:

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

Usunięcie niektórych zmaterializowanych cech widoku Feature View

Usunięcie niektórych, ale nie wszystkich zmaterializowanych cech Feature View ze zbioru materializacji jest odrzucane. Zobacz Zmiana zbioru materializacji.

Poniżej znajduje się zestaw amounts zdefiniowany w kroku 5 dla Feature View amount_sum, który ma okno piłozębne, i usuwa jedynie cechę zmaterializowaną w trybie offline w partii:

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

Edycja usuwa wsadową materializowaną cechę offline amount_sum, a to usunięcie usuwa także pozostałe dwie materializowane cechy tego samego Widoku Cech, o które edycja nie prosi. Wdrożenie zostaje odrzucone:

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)

Krok 10: Posprzątaj

Potoki materializacyjne działają zgodnie z skonfigurowanym harmonogramem, aż zestaw zostanie usunięty. Usuń pakiet, gdy skończysz:

databricks bundle destroy

Usuwa to zestawy materializacji oraz Feature Views zadeklarowane w każdym pliku zawieranym przez pakiet. Tabele, potoki przetwarzania i zadania stojące za materializowaną cechą są usuwane przez proces w tle po zniknięciu ostatniej materializowanej cechy, która je współdzieli, więc istnieje krótkie opóźnienie, zanim powiązane koszty przestaną być naliczane. Tylko użytkownik, który stworzył zmaterializowaną funkcję, może ją usunąć, więc uruchom databricks bundle destroy ją jako tę samą tożsamość, która wdrożyła pakiet. Zobacz: delete_materialized_feature().

Jakie koszty materializacji i jak je przypisać znajdziesz w Feature Store cost management.

Limitations

  • Strumień nie jest zasobem pakietowym. Stwórz go poza pakietem i odwołuj się do niego po nazwie.
  • Dodanie zmaterializowanego atrybutu do istniejącego zbioru materializacji odtwarza ten zbiór, więc każdy zmaterializowany atrybut w nim jest ponownie obliczany.
  • Widok cech oparty na request_source lub feature_view_source albo wykorzystujący funkcję custom_udf nie może zostać zmaterializowany. Zobacz Materialize Feature Views.

Następne kroki