Platform For AI:FeatureDB overview

What is FeatureDB

FeatureDB stores features in KV and KKV formats with native Array and Map support. Unlike serialized string storage, structured storage improves read, write, and inference performance. FeatureDB handles offline features, real-time features, and behavior sequences within a single system.

FeatureDB shards data within each feature view and adjusts shard count based on your Estimated Order of Magnitude:

Replicas are supported for data stability. Shard count scales up as performance needs grow.

Activate FeatureDB

Activate FeatureDB when creating a FeatureDB data store by following the interface prompts.

Capabilities

FeatureDB provides:

• Read and write KV and KKV features

• Read and write MaxCompute complex types (Array and Map)

• Pull all feature data in a feature view

• Millisecond polling for real-time feature updates

• Second-level TTL (time-to-live) with automatic expired data cleanup

• Pay-as-you-go billing based on actual operations

Advantages

Lower costs

Reduces storage expenses, particularly for smaller feature sets.

High-frequency updates

Real-time statistical features update every few seconds across multiple EasyRec Processor instances.

Native complex types

Search and advertising workloads commonly use Array, Map, behavior sequences, and SideInfo. String serialization degrades performance at scale. FeatureDB stores these types natively and synchronizes MaxCompute 2.0 complex data, enabling high-performance reads without deserialization overhead.

Elastic scaling

Increase shards per feature view to scale read and write throughput for larger deployments.

Comprehensive monitoring

Monitor read/write QPS, RT, data update latency, and storage at feature view granularity. This eliminates blind spots when integrating third-party data sources.

Low latency

With VPC direct connection configured and your online service deployed in a recommended zone, single-key reads achieve an average latency of 0.89 ms and TP99 of 1.45 ms (260-column feature table, 17.7M rows, tested with FeatureStore Go SDK on a 4-core/8 GiB machine). See Performance benchmarks for full results.

How it works

The FeatureStore storage service has three components: Feature Service (access layer), MSMQ (DataHub), and FeatureDB.

Write path: Write real-time features to FeatureDB via FeatureStore Java SDK or Flink Connector. Data also synchronizes to your MaxCompute table for feature export and model training.

Read path: Read features via FeatureStore Java/Go SDK, or use EasyRec Processor to pull all features into local cache for higher throughput. Real-time features are available within milliseconds of being written.

Set up VPC direct connection

FeatureDB uses PrivateLink to provide VPC (Virtual Private Cloud) direct connection. After configuration, access FeatureDB from your VPC via FeatureStore SDK through a private connection, improving throughput and reducing latency.

Method 1: No existing FeatureDB data store

1. On the Store tab, click Create Source.

2. Under VPC Direct Connection Configurations, set VPC, Zone and vSwitch, and Security Group Name.

For details, see Online data store: FeatureDB.

Method 2: Existing FeatureDB data source

1. On the Store tab, click feature_db.

2. Click VPC Direct Connection Configurations.

3. Specify VPC, Zone and vSwitch, and Security Group Name, then click OK.

Write data

Offline features: Use FeatureStore Python SDK to run scheduled tasks through DataWorks, synchronizing data from MaxCompute to FeatureDB.

       // Initialize configuration with region, credentials, and project
       Configuration configuration = new Configuration("cn-beijing",
                Constants.accessId, Constants.accessKey,"fs_demo_featuredb" );

        // Set FeatureDB credentials
        configuration.setUsername(Constants.username);
        configuration.setPassword(Constants.password);

        // For public network access, set domain (omit for VPC)
        //configuration.setDomain(Constants.host);

        ApiClient client = new ApiClient(configuration);

        // For public network, set usePublicAddress = true (omit for VPC)
        // FeatureStoreClient featureStoreClient = new FeatureStoreClient(client, Constants.usePublicAddress);
        FeatureStoreClient featureStoreClient = new FeatureStoreClient(client );

        // Get project and feature view
        Project project = featureStoreClient.getProject("fs_demo_featuredb");
        if (null == project) {
            throw  new RuntimeException("project not found");
        }

        FeatureView featureView = project.getFeatureView("user_test_2");
        if (null == featureView) {
            throw  new RuntimeException("featureview not found");
        }

        // Prepare sample data
        List<Map<String, Object>> writeData = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Map<String, Object> data = new HashMap<>();
            data.put("user_id", i);
            data.put("string_field", String.format("test_%d", i));
            data.put("int32_field", i);
            data.put("int64_field", Long.valueOf(i));
            data.put("float_field", Float.valueOf(i));
            data.put("double_field", Double.valueOf(i));
            data.put("boolean_field", i % 2 == 0);
            writeData.add(data);
        }

        // Write data in batches
        for (int i = 0; i < 100;i++) {
            featureView.writeFeatures(writeData);
        }

        // Flush all writes (call once after all writes complete)
        featureView.writeFlush();

Real-time features: Write directly using the Java SDK.

// Initialize configuration with region, credentials, and project
Configuration configuration = new Configuration("cn-beijing",
         Constants.accessId, Constants.accessKey, "fs_demo_featuredb");

// Set FeatureDB credentials
configuration.setUsername(Constants.username);
configuration.setPassword(Constants.password);

// For public network access, set domain (omit for VPC)
//configuration.setDomain(Constants.host);

ApiClient client = new ApiClient(configuration);

// For public network, set usePublicAddress = true (omit for VPC)
// FeatureStoreClient featureStoreClient = new FeatureStoreClient(client, Constants.usePublicAddress);
FeatureStoreClient featureStoreClient = new FeatureStoreClient(client);

// Get project and feature view
Project project = featureStoreClient.getProject("fs_demo_featuredb");
if (null == project) {
    throw new RuntimeException("project not found");
}

FeatureView featureView = project.getFeatureView("user_test_2");
if (null == featureView) {
    throw new RuntimeException("featureview not found");
}

// Prepare sample data
List<Map<String, Object>> writeData = new ArrayList<>();
for (int i = 0; i < 10; i++) {
    Map<String, Object> data = new HashMap<>();
    data.put("user_id", i);
    data.put("string_field", String.format("test_%d", i));
    data.put("int32_field", i);
    data.put("int64_field", Long.valueOf(i));
    data.put("float_field", Float.valueOf(i));
    data.put("double_field", Double.valueOf(i));
    data.put("boolean_field", i % 2 == 0);
    writeData.add(data);
}

// Write data in batches
for (int i = 0; i < 100; i++) {
    featureView.writeFeatures(writeData);
}

// Flush all writes (call once after all writes complete)
featureView.writeFlush();

By default, each write overwrites the entire row—unwritten fields are cleared. To update only specific fields while preserving others, use partial field write mode:

• Java SDK: Pass InsertMode.PartialFieldWrite to writeFeatures.

  for (int i = 0; i < 100; i++) {
      featureView.writeFeatures(writeData, InsertMode.PartialFieldWrite);
  }

• Flink Connector: Set insert_mode to partial_field_write.

Read data

Read features using FeatureStore SDK (Go or Java) or EasyRec Processor.

Monitor metrics

After creating a feature view with FeatureDB as the online data source, click Data Monitoring on the right side of the target view to see read/write QPS and RT per feature view.

Manage feature lifecycle

Specify Feature Lifecycle when creating a real-time feature view. Rows that reach the lifecycle threshold expire and are automatically deleted within seconds.

Survival time is calculated using one of two methods:

Method 1: No Event Time field

Survival time starts from the actual data write time.

Method 2: Event Time field enabled (unit: milliseconds)

Let event_time be the Event Time value, time_now be the current time, and time_ttl = time_now - TTL be the expiration threshold.

Additional rules:

• In PartialFieldWrite mode, survival time always uses the actual write time, regardless of event_time.

• event_time becomes the row timestamp (ts) in FeatureDB. To update an existing key, the new event_time must equal or exceed the previous value—otherwise the update is dropped.

• Event Time unit is milliseconds. If your field stores seconds, writes will fail silently.

Performance benchmarks

The following results use FeatureStore Go SDK to read a feature table with 17,689,586 rows of user-side recommendation data and 260 feature columns. Test machine: 4 cores, 8 GiB memory. Results are for reference only.

VPC direct connection, recommended zone

VPC direct connection, non-recommended zone

No VPC direct connection

Billing

For billing details, see Billing of FeatureStore. FeatureDB uses pay-as-you-go pricing based on actual operations.