Notatka
Dostęp do tej strony wymaga autoryzacji. Może spróbować zalogować się lub zmienić katalogi.
Dostęp do tej strony wymaga autoryzacji. Możesz spróbować zmienić katalogi.
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
- Databricks CLI w wersji 1.24.0 lub nowszej. Uruchom
databricks --version, aby sprawdzić. Zobacz Instalowanie lub aktualizowanie interfejsu wiersza poleceń Databricks. - Silnik bezpośredniego wdrożenia. Zasoby
featuresandmaterialization_setsnie są obsługiwane przez silnik wdrożeniowy Terraform. Zobacz Kompatybilność zasobów. - Obszar roboczy z włączoną obsługą Unity Catalog. Zobacz Wymagania.
- Uprawnienia do tworzenia obiektów i ich materializacji. Zobacz Uprawnienia.
- Istniejący sklep internetowy. Zobacz Stwórz sklep internetowy.
- Istniejąca tabela Delta z kolumną encji i kolumną znacznika czasu, przeznaczoną do materializacji wsadowej. Zobacz tabele Azure Databricks.
- Istniejący Stream do materializacji strumienia. Zobacz Utwórz stream.
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.
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ładhttps://adb-1234567890123456.7.azuredatabricks.net.databricks auth login --host <workspace-url>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 poleceniedatabricks auth env --profile <profile-name>.W przeglądarce internetowej wykonaj instrukcje na ekranie, aby zalogować się do obszaru roboczego usługi Azure Databricks.
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--hosti-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:
Usuń zmaterializowane cechy widoku funkcji z zestawu i wdroż. Zestaw jest aktualizowany na miejscu, jak w Usuwanie wszystkich zmaterializowanych cech widoku cech.
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 unchangedPo 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_sourcelubfeature_view_sourcealbo wykorzystujący funkcjęcustom_udfnie może zostać zmaterializowany. Zobacz Materialize Feature Views.
Następne kroki
- Aby wdrożyć te zasoby z workflow CI/CD, zobacz CI/CD dla Feature Views z GitHub Actions.
- Aby udostępnić te funkcje z pakietu, zobacz Udostępnianie widoków funkcji za pomocą pakietów deklaratywnej automatyzacji. Aby obsługiwać je za pomocą interfejsu API Python, zobacz Serwowanie widoków funkcji oraz Przykład: Wdrażanie i wykonywanie zapytań do punktu końcowego serwowania funkcji.
- Aby wytrenować model na nich, zobacz Train models with Feature Views.
- Pełny opis konfiguracji można znaleźć w artykule feature i materialization_set.
- Aby dowiedzieć się, jak działa materializacja, zobacz Materialize Feature Views.