Java Feature Server

Relevant source files

Purpose and Scope

The Java Feature Server is a JVM-based implementation of Feast's online feature serving service. It exposes a gRPC API defined in protos/feast/serving/ServingService.proto and provides low-latency retrieval of pre-materialized feature values from online stores. This server is the quay.io/feastdev/feature-server-java Docker image, deployed on Kubernetes via the infra/charts/feast/charts/feature-server Helm subchart.

This document covers the gRPC API contract, request/response message structure, FieldStatus semantics, online store backend implementations (Redis, BigQuery), and the deployment and configuration model. For the Python-based feature server, see page 4.1. For the Go implementation, see page 4.2.

Sources: protos/feast/serving/ServingService.proto1-136 infra/charts/feast/README.md1-82 infra/charts/feast/charts/feature-server/README.md1-68

Architecture Overview

The Java Feature Server is built on Spring Boot with reactive programming support via Project Reactor. It exposes gRPC endpoints for feature retrieval and is designed to integrate seamlessly with multiple online store backends.

Maven Module Structure

The Java Feature Server is organized into multiple Maven modules under java/:

Maven Module (`artifactId`)	Directory	Purpose
`feast-parent`	`java/`	Root POM; shared build config, dependency versions
`feast-datatypes`	`java/datatypes/`	Protobuf-generated Java types from `protos/feast/`
`feast-serving`	`java/serving/`	gRPC `ServingService` implementation; online store backends
`feast-serving-client`	`java/serving-client/`	Java client library for calling the server
`coverage`	`java/coverage/`	JaCoCo aggregated coverage report

Sources: java/pom.xml30-35

Maven Module Dependency Diagram

Sources: java/pom.xml30-35 protos/feast/serving/ServingService.proto24-27

Technology Stack

Dependency	Version	Role
gRPC	1.63.0	RPC transport for `ServingService`
Protobuf	3.25.5	Serialization of `Value`, `RepeatedValue`, `FeatureVector`
Project Reactor	3.4.34	Reactive, non-blocking I/O for store reads
Netty	4.1.96.Final	Underlying network transport layer
Spring Boot	(managed)	Application framework, config loading
Jackson	2.15.0	JSON processing
Guava	32.0.0-jre	Utilities
Lombok	1.18.24	Code generation (builders, accessors)
Log4j2	2.17.1	Structured logging (JSON or Console)

Sources: java/pom.xml44-72

gRPC API Contract

The entire serving API is defined in protos/feast/serving/ServingService.proto. The generated Java classes land in the feast.proto.serving package (outer class ServingAPIProto).

ServingService RPC Methods

RPC Method	Request	Response	Description
`GetFeastServingInfo`	`GetFeastServingInfoRequest`	`GetFeastServingInfoResponse`	Returns the Feast version string of this deployment
`GetOnlineFeatures`	`GetOnlineFeaturesRequest`	`GetOnlineFeaturesResponse`	Retrieves online feature values for one or more entity rows

Sources: protos/feast/serving/ServingService.proto28-33

`GetOnlineFeaturesRequest`

Features can be requested either by a named FeatureService or by listing individual feature references:

Field	Type	Description
`feature_service`	`string` (oneof)	Name of a registered `FeatureService` to retrieve
`features`	`FeatureList` (oneof)	Explicit list of `"feature_view_name:feature_name"` strings
`entities`	`map<string, RepeatedValue>`	Columnar entity data: entity name → list of values
`full_feature_names`	`bool`	If true, response uses `"view_name__feature_name"` format
`request_context`	`map<string, RepeatedValue>`	Additional context values for `OnDemandFeatureView` transformations

Sources: protos/feast/serving/ServingService.proto80-94

`GetOnlineFeaturesResponse` and `FeatureVector`

The response is columnar: a list of FeatureVector entries, one per requested feature, aligned with the feature_names metadata list.

metadata.feature_names — ordered list of feature names returned
results[i] — FeatureVector for the i-th feature in feature_names
Within a FeatureVector, index j corresponds to entity row j from the request

Sources: protos/feast/serving/ServingService.proto96-114

`FieldStatus` Enum

Each value in a FeatureVector.statuses array carries a FieldStatus tag indicating data quality for that (entity, feature) pair.

Value	Integer	Meaning
`INVALID`	0	Status unset; should not appear in a valid response
`PRESENT`	1	Feature value found and within the max age window
`NULL_VALUE`	2	Entity found, but this feature was not assigned a value during ingestion
`NOT_FOUND`	3	No feature values found for this entity key in the store
`OUTSIDE_MAX_AGE`	4	Value found but older than the feature view's `max_age` TTL

Sources: protos/feast/serving/ServingService.proto116-135

Legacy `GetOnlineFeaturesRequestV2`

The proto also defines a legacy GetOnlineFeaturesRequestV2 message (with FeatureReferenceV2 and per-row EntityRow messages) marked with a TODO for removal. Current implementations should use GetOnlineFeaturesRequest.

Sources: protos/feast/serving/ServingService.proto51-73

Deployment Model

The Java Feature Server is distributed as a Docker container and deployed via Helm charts on Kubernetes. The primary deployment target is cloud-native environments where it can scale horizontally.

Container Image

The server is published as a Docker image to Quay.io:

quay.io/feastdev/feature-server-java:0.60.0

This image contains:

Java 11 runtime environment
Compiled Spring Boot application JAR
Default configuration (application.yaml)
Health check endpoints

Sources: infra/charts/feast/charts/feature-server/values.yaml4-10

Helm Chart Deployment

Helm Chart Structure:

The feature server is deployed as a subchart within the main Feast Helm chart at infra/charts/feast/charts/feature-server/. The chart creates:

Deployment: Manages ReplicaSets and Pods running the feature server
Service: Exposes the server on port 6566 (gRPC)
ConfigMap: Stores application-override.yaml configuration
Secret: (Optional) Stores application-secret.yaml for sensitive config
Ingress: (Optional) Exposes the service externally with TLS support

Sources: infra/charts/feast/README.md1-82 infra/charts/feast/requirements.yaml1-15

Service Configuration

The Kubernetes Service exposes the feature server on a ClusterIP by default:

Parameter	Default Value	Description
`service.type`	`ClusterIP`	Kubernetes service type
`service.grpc.port`	`6566`	Service port for gRPC requests
`service.grpc.targetPort`	`6566`	Container port serving gRPC
`service.grpc.nodePort`	(unset)	NodePort if service type is NodePort

For production deployments, an Ingress resource can be configured to expose the service externally with TLS termination:

Sources: infra/charts/feast/charts/feature-server/values.yaml71-80 infra/charts/feast/charts/feature-server/values.yaml82-122

Configuration

The Java Feature Server uses a layered configuration system based on Spring Boot's application.yaml mechanism. Configuration can be provided through multiple sources with clear precedence rules.

Configuration Layers

Configuration Precedence (Lowest to Highest):

application.yaml: Default configuration bundled in the JAR
application-generated.yaml: Generated by Helm from chart values
application-secret.yaml: Sensitive configuration (Kubernetes Secret)
application-override.yaml: User-provided overrides (Kubernetes ConfigMap)

Sources: infra/charts/feast/charts/feature-server/values.yaml18-32

Example Configuration

To configure the feature server to use Redis as the online store:

Sources: infra/charts/feast/README.md33-54

Key Configuration Options

Configuration Path	Description
`feast.active_store`	Name of the active online store configuration
`feast.stores`	List of online store configurations
`feast.entityKeySerializationVersion`	Entity key serialization version (2 or 3)
`global.registry.path`	Path to the Feast registry file
`global.registry.cache_ttl_seconds`	Registry cache TTL in seconds
`global.project`	Feast project name
`transformationService.host`	Host for transformation service
`transformationService.port`	Port for transformation service

The transformation service configuration allows the feature server to delegate on-demand feature transformations to a separate Python service:

Sources: infra/charts/feast/charts/feature-server/values.yaml13-15 infra/charts/feast/README.md76-82

JVM Options

For production deployments, JVM options can be configured to optimize heap size and garbage collection:

Recommended settings:

Heap Size: Set -Xms and -Xmx to the same value for predictable performance
Garbage Collector: Use G1GC (-XX:+UseG1GC) for balanced throughput and latency
GC Pause Time: Target max pause time with -XX:MaxGCPauseMillis=200

Sources: infra/charts/feast/charts/feature-server/values.yaml34-35

Integration with Feast Ecosystem

The Java Feature Server integrates with multiple components of the Feast ecosystem to provide end-to-end feature serving capabilities.

Registry Integration

The feature server loads feature definitions from the registry, which is managed by the Python SDK. The registry contains:

Feature Views: Schema and metadata for feature definitions
Entities: Entity definitions with join keys
Data Sources: Information about offline data sources
Feature Services: Logical groupings of features

The registry is cached in-memory with a configurable TTL (cache_ttl_seconds) to minimize latency. The server supports multiple registry backend types:

File-based: Local filesystem or network-mounted storage
GCS: Google Cloud Storage (gs:// URIs)
S3: AWS S3 (s3:// URIs)
SQL: PostgreSQL, MySQL, or other JDBC-compatible databases

Sources: infra/charts/feast/README.md49-52

Online Store Integration

The Java Feature Server reads pre-materialized feature values from configured online store backends. The store type is set via feast.stores[].type in application.yaml.

Request Processing Flow

Supported Online Store Backends

Store Type (`feast.stores[].type`)	Notes
`REDIS`	Primary production backend; configured via `host`, `port`, optional TLS/auth
`BIGTABLE`	Google Cloud Bigtable
`CASSANDRA`	Apache Cassandra

Redis Backend

Redis is the most common online store for the Java feature server. Configuration example from application.yaml:

The server stores feature values as serialized feast.types.Value protobuf bytes, keyed by a binary-encoded entity key. The entityKeySerializationVersion (2 or 3) must match the version used during materialization by the Python SDK.

BigQuery Backend

The Java feature server also supports BigQuery as a serving backend for batch/historical retrieval scenarios. When configured, the server issues BigQuery read API calls instead of online store lookups. This is typically used for feature retrieval patterns where latency requirements are less strict and data freshness from BigQuery is acceptable.

Sources: infra/charts/feast/README.md33-54 infra/charts/feast/charts/feature-server/values.yaml18-32

Transformation Service Integration

For OnDemandFeatureView transformations requiring Python execution, the Java Feature Server delegates to the transformation-service (image: quay.io/feastdev/feature-transformation-server).

Transformation Request Flow

The transformation service host is configured in the feature server values:

In the parent Feast Helm chart, the transformation service deploys as a sibling deployment when transformation-service.enabled: true.

Sources: infra/charts/feast/charts/feature-server/values.yaml13-15 infra/charts/feast/charts/transformation-service/values.yaml1-37 infra/charts/feast/requirements.yaml7-11

Operational Characteristics

Health Checks and Probes

The feature server implements Kubernetes health check endpoints for liveness and readiness probes:

Probe Type	Default Config	Purpose
Liveness	`initialDelaySeconds: 60` `periodSeconds: 10` `timeoutSeconds: 5`	Determines if the pod should be restarted
Readiness	`initialDelaySeconds: 15` `periodSeconds: 10` `timeoutSeconds: 10`	Determines if the pod can receive traffic

Both probes check:

Server process is running
gRPC server is accepting connections
Registry is loaded and accessible

Sources: infra/charts/feast/charts/feature-server/values.yaml43-69

Logging Configuration

Logging output format and level are configurable:

logType: Console: Human-readable format for development
logType: JSON: Structured JSON logs for production (ELK/Splunk ingestion)

Sources: infra/charts/feast/charts/feature-server/values.yaml37-40

Resource Requirements

Resource requirements should be configured based on workload characteristics:

Sizing Guidelines:

CPU: 1 core can typically serve 1000-5000 QPS depending on feature count
Memory: 2GB base + (number of feature views × 100MB) for registry cache
Heap: Set to 50-70% of container memory limit

Sources: infra/charts/feast/charts/feature-server/values.yaml124-125

Performance Characteristics

The Java Feature Server is optimized for low-latency feature serving:

Reactive I/O: Project Reactor enables non-blocking database queries
Connection Pooling: Reusable connections to online stores reduce overhead
Registry Caching: In-memory cache eliminates registry roundtrips
Batch Reads: Multiple entity lookups are batched into single store queries
Protobuf Serialization: Efficient binary serialization format

Typical latencies (P99):

Single entity, 10 features from Redis: < 5ms
Batch of 100 entities, 10 features from Redis: < 20ms
With on-demand transformations (Python UDF): + 10-50ms overhead

Sources: java/pom.xml71-72 java/pom.xml228-232

Build and Release Process

Maven Build

The Java Feature Server is built using Apache Maven with a multi-module structure:

Build artifacts:

serving/target/feast-serving-{version}.jar - Executable Spring Boot JAR
serving-client/target/feast-serving-client-{version}.jar - Java client library
datatypes/target/feast-datatypes-{version}.jar - Protobuf data types

Build requirements:

Maven: 3.6 or higher
Java: JDK 11 or higher
Protoc: 3.12.2 (for regenerating protobufs)

Sources: java/pom.xml354-396

Docker Image Build

Docker images are built as part of the CI/CD pipeline and published to Quay.io:

quay.io/feastdev/feature-server-java:{version}

The image build process:

Compile Java code with Maven
Package Spring Boot fat JAR
Create minimal Docker image with JRE 11
Add health check and default configuration