Adding a new online store

Overview
Feast makes adding support for a new online store (database) easy. Developers can simply implement the OnlineStore interface to add support for a new store (other than the existing stores like Redis, DynamoDB, SQLite, and Datastore).
In this guide, we will show you how to integrate with MySQL as an online store. While we will be implementing a specific store, this guide should be representative for adding support for any new online store.
The full working code for this guide can be found at feast-dev/feast-custom-online-store-demo.
The process of using a custom online store consists of 3 steps:
1.Defining the OnlineStore class.
2.Defining the OnlineStoreConfig class.
3.Referencing the OnlineStore in a feature repo's feature_store.yaml file.
4.Testing the OnlineStore class.
1. Defining an OnlineStore class
OnlineStore class names must end with the OnlineStore suffix!
The OnlineStore class broadly contains two sets of methods
One set deals with managing infrastructure that the online store needed for operations
One set deals with writing data into the store, and reading data from the store.
1.1 Infrastructure Methods
There are two methods that deal with managing infrastructure for online stores, update and teardown
update is invoked when users run feast apply as a CLI command, or the FeatureStore.apply() sdk method.
The update method should be used to perform any operations necessary before data can be written to or read from the store. The update method can be used to create MySQL tables in preparation for reads and writes to new feature views.
teardown is invoked when users run feast teardown or FeatureStore.teardown().
The teardown method should be used to perform any clean-up operations. teardown can be used to drop MySQL indices and tables corresponding to the feature views being deleted.
feast_custom_online_store/mysql.py
1
def update(
2
    self,
3
    config: RepoConfig,
4
    tables_to_delete: Sequence[Union[FeatureTable, FeatureView]],
5
    tables_to_keep: Sequence[Union[FeatureTable, FeatureView]],
6
    entities_to_delete: Sequence[Entity],
7
    entities_to_keep: Sequence[Entity],
8
    partial: bool,
9
):
10
    """
11
    An example of creating manging the tables needed for a mysql-backed online store.
12
    """
13
    conn = self._get_conn(config)
14
    cur = conn.cursor(buffered=True)
15
​
16
    project = config.project
17
​
18
    for table in tables_to_keep:
19
        cur.execute(
20
            f"CREATE TABLE IF NOT EXISTS {_table_id(project, table)} (entity_key VARCHAR(512), feature_name VARCHAR(256), value BLOB, event_ts timestamp, created_ts timestamp,  PRIMARY KEY(entity_key, feature_name))"
21
        )
22
        cur.execute(
23
            f"CREATE INDEX {_table_id(project, table)}_ek ON {_table_id(project, table)} (entity_key);"
24
        )
25
​
26
    for table in tables_to_delete:
27
        cur.execute(
28
            f"DROP INDEX {_table_id(project, table)}_ek ON {_table_id(project, table)};"
29
        )
30
        cur.execute(f"DROP TABLE IF EXISTS {_table_id(project, table)}")
31
​
32
​
33
def teardown(
34
    self,
35
    config: RepoConfig,
36
    tables: Sequence[Union[FeatureTable, FeatureView]],
37
    entities: Sequence[Entity],
38
):
39
    """
40
    
41
    """
42
    conn = self._get_conn(config)
43
    cur = conn.cursor(buffered=True)
44
    project = config.project
45
​
46
    for table in tables:
47
        cur.execute(
48
            f"DROP INDEX {_table_id(project, table)}_ek ON {_table_id(project, table)};"
49
        )
50
        cur.execute(f"DROP TABLE IF EXISTS {_table_id(project, table)}")
Copied!
1.2 Read/Write Methods
There are two methods that deal with writing data to and from the online stores.online_write_batch and online_read.
online_write_batch is invoked when running materialization (using the feast materialize or feast materialize-incremental commands, or the corresponding FeatureStore.materialize() method.
online_read is invoked when reading values from the online store using the FeatureStore.get_online_features() method.
feast_custom_online_store/mysql.py
1
def online_write_batch(
2
    self,
3
    config: RepoConfig,
4
    table: Union[FeatureTable, FeatureView],
5
    data: List[
6
        Tuple[EntityKeyProto, Dict[str, ValueProto], datetime, Optional[datetime]]
7
    ],
8
    progress: Optional[Callable[[int], Any]],
9
) -> None:
10
    conn = self._get_conn(config)
11
    cur = conn.cursor(buffered=True)
12
​
13
    project = config.project
14
​
15
    for entity_key, values, timestamp, created_ts in data:
16
        entity_key_bin = serialize_entity_key(entity_key).hex()
17
        timestamp = _to_naive_utc(timestamp)
18
        if created_ts is not None:
19
            created_ts = _to_naive_utc(created_ts)
20
​
21
        for feature_name, val in values.items():
22
            self.write_to_table(created_ts, cur, entity_key_bin, feature_name, project, table, timestamp, val)
23
        self._conn.commit()
24
        if progress:
25
            progress(1)
26
​
27
def online_read(
28
    self,
29
    config: RepoConfig,
30
    table: Union[FeatureTable, FeatureView],
31
    entity_keys: List[EntityKeyProto],
32
    requested_features: Optional[List[str]] = None,
33
) -> List[Tuple[Optional[datetime], Optional[Dict[str, ValueProto]]]]:
34
    conn = self._get_conn(config)
35
    cur = conn.cursor(buffered=True)
36
​
37
    result: List[Tuple[Optional[datetime], Optional[Dict[str, ValueProto]]]] = []
38
​
39
    project = config.project
40
    for entity_key in entity_keys:
41
        entity_key_bin = serialize_entity_key(entity_key).hex()
42
        print(f"entity_key_bin: {entity_key_bin}")
43
​
44
        cur.execute(
45
            f"SELECT feature_name, value, event_ts FROM {_table_id(project, table)} WHERE entity_key = %s",
46
            (entity_key_bin,),
47
        )
48
​
49
        res = {}
50
        res_ts = None
51
        for feature_name, val_bin, ts in cur.fetchall():
52
            val = ValueProto()
53
            val.ParseFromString(val_bin)
54
            res[feature_name] = val
55
            res_ts = ts
56
​
57
        if not res:
58
            result.append((None, None))
59
        else:
60
            result.append((res_ts, res))
61
    return result
Copied!
2. Defining an OnlineStoreConfig class
Additional configuration may be needed to allow the OnlineStore to talk to the backing store. For example, MySQL may need configuration information like the host at which the MySQL instance is running, credentials for connecting to the database, etc.
To facilitate configuration, all OnlineStore implementations are required to also define a corresponding OnlineStoreConfig class in the same file. This OnlineStoreConfig class should inherit from the FeastConfigBaseModel class, which is defined here.
The FeastConfigBaseModel is a pydantic class, which parses yaml configuration into python objects. Pydantic also allows the model classes to define validators for the config classes, to make sure that the config classes are correctly defined.
This config class must container a type field, which contains the fully qualified class name of its corresponding OnlineStore class.
Additionally, the name of the config class must be the same as the OnlineStore class, with the Config suffix.
An example of the config class for MySQL :
feast_custom_online_store/mysql.py
1
class MySQLOnlineStoreConfig(FeastConfigBaseModel):
2
    type: Literal["feast_custom_online_store.mysql.MySQLOnlineStore"] = "feast_custom_online_store.mysql.MySQLOnlineStore"
3
​
4
    host: Optional[StrictStr] = None
5
    user: Optional[StrictStr] = None
6
    password: Optional[StrictStr] = None
7
    database: Optional[StrictStr] = None
Copied!
This configuration can be specified in the feature_store.yaml as follows:
feature_repo/feature_store.yaml
1
online_store:
2
    type: feast_custom_online_store.mysql.MySQLOnlineStore
3
    user: foo
4
    password: bar
Copied!
This configuration information is available to the methods of the OnlineStore, via theconfig: RepoConfig parameter which is passed into all the methods of the OnlineStore interface, specifically at the config.online_store field of the config parameter.
feast_custom_online_store/mysql.py
1
def online_write_batch(
2
        self,
3
        config: RepoConfig,
4
        table: Union[FeatureTable, FeatureView],
5
        data: List[
6
            Tuple[EntityKeyProto, Dict[str, ValueProto], datetime, Optional[datetime]]
7
        ],
8
        progress: Optional[Callable[[int], Any]],
9
) -> None:
10
​
11
    online_store_config = config.online_store
12
    assert isinstance(online_store_config, MySQLOnlineStoreConfig)
13
​
14
    connection = mysql.connector.connect(
15
        host=online_store_config.host or "127.0.0.1",
16
        user=online_store_config.user or "root",
17
        password=online_store_config.password,
18
        database=online_store_config.database or "feast",
19
        autocommit=True
20
    )
Copied!
3. Using the custom online store
After implementing both these classes, the custom online store can be used by referencing it in a feature repo's feature_store.yaml file, specifically in the online_store field. The value specified should be the fully qualified class name of the OnlineStore.
As long as your OnlineStore class is available in your Python environment, it will be imported by Feast dynamically at runtime.
To use our MySQL online store, we can use the following feature_store.yaml:
feature_repo/feature_store.yaml
1
project: test_custom
2
registry: data/registry.db
3
provider: local
4
online_store: 
5
    type: feast_custom_online_store.mysql.MySQLOnlineStore
6
    user: foo
7
    password: bar
Copied!
If additional configuration for the online store is **not **required, then we can omit the other fields and only specify the type of the online store class as the value for the online_store.
feature_repo/feature_store.yaml
1
project: test_custom
2
registry: data/registry.db
3
provider: local
4
online_store: feast_custom_online_store.mysql.MySQLOnlineStore
Copied!
4. Testing the OnlineStore class
Even if you have created the OnlineStore class in a separate repo, you can still test your implementation against the Feast test suite, as long as you have Feast as a submodule in your repo. In the Feast submodule, we can run all the unit tests with:
1
make test
Copied!
The universal tests, which are integration tests specifically intended to test offline and online stores, can be run with:
1
make test-python-universal
Copied!
The unit tests should succeed, but the universal tests will likely fail. The tests are parametrized based on the FULL_REPO_CONFIGS variable defined in sdk/python/tests/integration/feature_repos/repo_configuration.py. To overwrite these configurations, you can simply create your own file that contains a FULL_REPO_CONFIGS, and point Feast to that file by setting the environment variable FULL_REPO_CONFIGS_MODULE to point to that file. In this repo, the file that overwrites FULL_REPO_CONFIGS is feast_custom_online_store/feast_tests.py, so you would run
1
export FULL_REPO_CONFIGS_MODULE='feast_custom_online_store.feast_tests'
2
make test-python-universal
Copied!
to test the MySQL online store against the Feast universal tests. You should notice that some of the tests actually fail; this indicates that there is a mistake in the implementation of this online store!

How-to Guides - Previous

Adding a custom provider

Next - How-to Guides

Adding a new offline store

Last modified 2mo ago

Export as PDF

Copy link

Edit on GitHub

Contents

Overview

1. Defining an OnlineStore class

1.1 Infrastructure Methods

1.2 Read/Write Methods

2. Defining an OnlineStoreConfig class

3. Using the custom online store

4. Testing the OnlineStore class