Register Redis providers

Register standalone Redis and Redis Cluster online-store providers with Redis Feature Form.

Register a Redis provider when feature views need an online-store for materialization and inference-time reads. A Redis provider doesn't supply offline storage or compute.

Choose a Redis provider type

Choose the type that matches the topology of the Redis deployment:

The redis-cluster provider discovers the cluster topology from its startup endpoints. It doesn't mean every Redis service or deployment with multiple nodes uses the Redis Cluster protocol. Confirm the connection mode and endpoint format for your deployment before choosing the provider type.

Before you begin

Make sure you have:

• A Feature Form workspace.
• Network access to Redis from the Feature Form server and any compute runtime that materializes feature views.
• A Redis host and port, or at least one Redis Cluster startup endpoint.
• A registered secret provider for the Redis password, if authentication is enabled.
• Certificate material available to each runtime that needs it, if Redis requires TLS or mutual TLS (mTLS).

The Python examples use this workspace-scoped provider client:

import featureform as ff

client = ff.Client.from_env()
providers = client.providers("<workspace-id>")

Choose authentication

Redis authentication configuration is the same for both provider types:

Feature Form rejects a username without a password secret. Use a secret reference such as env:REDIS_PASSWORD; don't put a password value in the provider definition. An environment reference resolves in the Feature Form server environment, not in the shell where you run the CLI.

Register standalone Redis

This example uses Redis ACL authentication:

from featureform.types import EnvSecretRef, ProviderType, RedisConfig

providers.register(
    name="<redis-provider-name>",
    provider_type=ProviderType.REDIS,
    config=RedisConfig(
        host="<redis-host>",
        port=int("<redis-port>"),
        username="<redis-username>",
        password_secret=EnvSecretRef(name="REDIS_PASSWORD"),
    ),
)

ff provider register <redis-provider-name> \
  --workspace <workspace-id> \
  --type redis \
  --redis-host <redis-host> \
  --redis-port <redis-port> \
  --redis-username <redis-username> \
  --redis-password-secret env:REDIS_PASSWORD

Omit the username and password fields for a deployment without authentication. For password-only authentication, omit only the username.

Standalone Redis uses database 0 by default. The Python client also supports databases 0 through 15 by setting database in RedisConfig. The CLI doesn't currently expose a database option, so CLI registration uses database 0.

Register Redis Cluster

Supply one or more startup endpoints. They aren't required to list every node because the provider discovers the cluster topology.

from featureform.types import EnvSecretRef, ProviderType, RedisClusterConfig

providers.register(
    name="<redis-cluster-provider-name>",
    provider_type=ProviderType.REDIS_CLUSTER,
    config=RedisClusterConfig(
        endpoints=[
            "<redis-host-1>:<redis-port>",
            "<redis-host-2>:<redis-port>",
        ],
        username="<redis-username>",
        password_secret=EnvSecretRef(name="REDIS_PASSWORD"),
    ),
)

ff provider register <redis-cluster-provider-name> \
  --workspace <workspace-id> \
  --type redis-cluster \
  --redis-cluster-startup-endpoints <redis-host-1>:<redis-port>,<redis-host-2>:<redis-port> \
  --redis-username <redis-username> \
  --redis-password-secret env:REDIS_PASSWORD

With the CLI, pass all startup endpoints as one comma-delimited --redis-cluster-startup-endpoints value. Don't repeat the flag. Redis Cluster uses database 0.

Configure TLS

Set a TLS mode when the Redis deployment requires an encrypted connection:

TLS 1.2 is the default minimum. Set the minimum version to 1.2 or 1.3 when you need to make it explicit. For verify-full and mtls, set server_name when the name used for certificate verification differs from the connection host.

This mTLS example uses file paths so the same configuration can be used by Feature Form and a Spark materialization runtime:

from featureform.types import (
    EnvSecretRef,
    ProviderType,
    RedisConfig,
    RedisTLSConfig,
    RedisTLSMode,
)

providers.register(
    name="<redis-provider-name>",
    provider_type=ProviderType.REDIS,
    config=RedisConfig(
        host="<redis-host>",
        port=int("<redis-port>"),
        username="<redis-username>",
        password_secret=EnvSecretRef(name="REDIS_PASSWORD"),
        tls=RedisTLSConfig(
            mode=RedisTLSMode.MTLS,
            ca_cert_path="<runtime-visible-ca-cert-path>",
            server_name="<redis-server-name>",
            client_cert_path="<runtime-visible-client-cert-path>",
            client_key_path="<runtime-visible-client-key-path>",
            min_version="1.2",
        ),
    ),
)

ff provider register <redis-provider-name> \
  --workspace <workspace-id> \
  --type redis \
  --redis-host <redis-host> \
  --redis-port <redis-port> \
  --redis-username <redis-username> \
  --redis-password-secret env:REDIS_PASSWORD \
  --redis-tls-mode mtls \
  --redis-tls-ca-cert-path <runtime-visible-ca-cert-path> \
  --redis-tls-server-name <redis-server-name> \
  --redis-tls-client-cert-path <runtime-visible-client-cert-path> \
  --redis-tls-client-key-path <runtime-visible-client-key-path> \
  --redis-tls-min-version 1.2

Certificate paths are resolved by the Feature Form server, not by the machine where you run the CLI. If Spark materializes the feature view, mount the same paths in the Spark runtime. Direct Feature Form connections can instead use the certificate secret fields, but Spark materialization doesn't project secret-backed Redis TLS certificates; use runtime-visible file paths for that workflow.

Use Redis with Databricks

The Feature Form server and Databricks compute must both be able to reach the Redis endpoint.

For both job_cluster and existing_cluster Spark materialization, configure password_secret as a Databricks secret reference. With job_cluster, Feature Form adds the reference to the job environment so Databricks can resolve it. With existing_cluster, the cluster resolves the scope and key directly. An environment, Kubernetes, Vault, or AWS secret reference can't be projected to either Databricks compute target. First register the Databricks secret provider, then use this reference format:

databricks@<databricks-secret-provider-name>:<secret-scope>#<redis-password-key>

See Connect Databricks compute to Redis for equivalent Python and CLI examples and the Databricks secret bootstrap requirements.

Redis TLS certificate paths must also be mounted at the configured locations in the Databricks runtime. Secret-backed Redis TLS certificate fields aren't projected to Spark.

Configuration reference

Standalone Redis

Redis Cluster

Redis TLS

Verify registration

ff provider get <redis-provider-name> --workspace <workspace-id>
ff provider list --workspace <workspace-id>

In Python, use providers.get("<redis-provider-name>") or providers.list().

Registration resolves the configured secrets, builds the Redis client, and sends a ping before persisting the provider. Keep this health check enabled so endpoint, authentication, TLS, and network errors fail during registration. --skip-health-check or skip_health_check=True skips only the registration-time check; it doesn't disable recurring monitoring.

Update safely

Changing endpoints or TLS settings can interrupt materialization and serving if the new configuration isn't reachable from every runtime. Test connectivity from the Feature Form server and compute runtime before forcing the update.

Troubleshoot registration

See Serve features for the serving workflow. To provision a managed deployment, see the Redis Cloud quick start.