Skip to main content
Version: 96.1

Deploy Factor Platform with Kubernetes

Factor Platform is a unified control plane for real-time data streaming that brings together Apache Kafka®, Apache Flink®, and beyond.

This Helm chart uses the factorhouse/factor-platform container from Dockerhub.

The Helm Charts source code is available at factorhouse/helm-charts.

Helm Charts

This repository contains a single Helm chart that uses the factorhouse/factor-platform container on Dockerhub.

Prerequisites​

See the requirements section for details on Factor Platform's dependencies and system requirements.

Kubernetes​

Configure Kubernetes/EKS​

You need to connect to a Kubernetes environment before you can install Factor Platform.

The following examples demonstrate installing Factor Platform in Amazon EKS.

aws eks --region <your-aws-region> update-kubeconfig --name <your-eks-cluster-name>

Updated context arn:aws:eks:<your-aws-region>:123123123:cluster/<your-eks-cluster-name> in /your/.kube/config

Confirm Kubernetes cluster availability​

kubectl get nodes

NAME                              STATUS   ROLES    AGE     VERSION
ip-192-168-...-21.ec2.internal   Ready    <none>   2m15s    v1.32.9-eks-113cf36
...

Run Factor Platform in Kubernetes​

Configure the Factor Platform Helm Repository​

Add the Factor House Helm Repository in order to use the Factor Platform Helm Chart.

helm repo add factorhouse https://charts.factorhouse.io

Update Helm repositories to ensure you install the latest version of Factor Platform.

helm repo update

Start a Factor Platform instance​

Start Factor Platform with config from '--set env.XYZ'​

When using helm install, you can pass configuration with the --set env.XYZ flag. This requires careful formatting for certain values.

Some fields, particularly integers and strings containing quotation marks, require quoting. You may also need to escape special characters (like commas or nested quotes) with a backslash (\). For more details, see Helm's documentation on The Format and Limitations of --set.

The following example shows how to install Factor Platform from the command line, highlighting how to handle escaped commas and quotes:

helm install platform factorhouse/factor-platform \
  --set env.LICENSE_ID="00000000-0000-0000-0000-000000000001" \
  --set env.LICENSE_CODE="PLATFORM" \
  --set env.LICENSEE="Factor House\, Inc." \ # <-- note the escaped comma
  --set env.LICENSE_EXPIRY="2027-01-01" \
  --set env.LICENSE_SIGNATURE="638......A51" \
  --set env.LICENSE_CREDITS="7" \
  --set env.BOOTSTRAP="127.0.0.1:9092\,127.0.0.1:9093\,127.0.0.1:9094" \ # <-- note the escaped commas
  --set env.SECURITY_PROTOCOL="SASL_PLAINTEXT" \
  --set env.SASL_MECHANISM="PLAIN" \
  --set env.SASL_JAAS_CONFIG="org.apache.kafka.common.security.plain.PlainLoginModule required username=\"user\" password=\"secret\";" \ # <-- note the escaped quotes
  --set env.FLINK_REST_URL="http://127.0.0.1:8081" \
  --set env.POSTGRES_HOST="postgres.factorhouse.svc.cluster.local" \
  --set env.POSTGRES_USER="factor_platform" \
  --set env.POSTGRES_PASSWORD="secure-password-here" \
  --set env.POSTGRES_DB_NAME="factor_platform" \
  --set env.POSTGRES_PORT="5432" \
  --set env.POSTGRES_SSL="false" \
  --set env.POSTGRES_SSLMODE="prefer" \
  --create-namespace --namespace factorhouse

NAME: platform
LAST DEPLOYED: Mon May 31 17:22:21 2025
NAMESPACE: factorhouse
STATUS: deployed
REVISION: 1
NOTES:
1. Get the application URL by running these commands:
  export POD_NAME=$(kubectl get pods --namespace factorhouse -l "app.kubernetes.io/name=factor-platform,app.kubernetes.io/instance=platform" -o jsonpath="{.items[0].metadata.name}")
  echo "Visit http://127.0.0.1:3000 to use your application"
  kubectl --namespace factorhouse port-forward $POD_NAME 3000:3000

Start Factor Platform with environment variables from a ConfigMap​

You can configure Factor Platform with a ConfigMap of environment variables as follows:

helm install platform factorhouse/factor-platform \
  --set envFromConfigMap=platform-config \
  --create-namespace --namespace factorhouse

This approach requires a ConfigMap named platform-config to already exist in the factorhouse namespace. To configure Factor Platform with a local ConfigMap template, see Configuring with an Existing ConfigMap. You can also refer to platform-config.yaml.example for a sample ConfigMap manifest.

For general guidance, see the Kubernetes documentation on configuring all key-value pairs in a ConfigMap as environment variables.

Manage a Factor Platform instance​

Set the $POD_NAME variable and test the Factor Platform UI​

Follow these instructions to set the $POD_NAME variable and configure port forwarding to the Factor Platform UI:

export POD_NAME=$(kubectl get pods --namespace factorhouse -l "app.kubernetes.io/name=factor-platform,app.kubernetes.io/instance=platform" -o jsonpath="{.items[0].metadata.name}")
echo "Visit http://127.0.0.1:3000 to use your application"
kubectl --namespace factorhouse port-forward $POD_NAME 3000:3000

Factor Platform is now available on http://127.0.0.1:3000.

Check the Factor Platform Pod​

kubectl describe pod $POD_NAME --namespace factorhouse

Name:             platform-factor-platform-6976f96b95-g5ft7
Namespace:        factorhouse
Priority:         0
Service Account:  platform
Node:             ip-10-0-1-115.ec2.internal/10.0.1.115
Start Time:       Tue, 23 Dec 2025 10:04:29 +1100
Labels:           app.kubernetes.io/instance=platform
                  app.kubernetes.io/name=factor-platform
                  pod-template-hash=6976f96b95
Annotations:      <none>
Status:           Running

View the Factor Platform Pod logs​

kubectl logs $POD_NAME --namespace factorhouse

23:04:35.707 INFO  [main] factorhouse.platform – Initializing Factor Platform - Enterprise - 95.1
...

Remove Factor Platform​

helm delete platform --namespace factorhouse

Start Factor Platform with local changes​

You can run Factor Platform with local edits to these charts and provide local configuration when running Factor Platform.

Pull and untar the Factor Platform Charts​

helm pull factorhouse/factor-platform --untar --untardir .

Make local edits​

Make any edits required to factor-platform/Chart.yaml or factor-platform/values.yaml (adding volume mounts, etc).

Run local charts​

The command to run local charts is slightly different, see ./factor-platform rather than factorhouse/factor-platform.

helm install platform ./factor-platform \
  <.. --set configuration, etc ..> \
  --create-namespace -namespace factorhouse

Configuring with an existing ConfigMap​

This is the recommended method for managing configuration separately from the Helm chart.

1. Prepare Your ConfigMap Manifest

Copy the example file (platform-config.yaml.example), then edit it to set your desired metadata.name (e.g., platform-config) and fill in your configuration under the data section.

cp ./factor-platform/platform-config.yaml.example platform-config.yaml
# now edit platform-config.yaml

2. Create the ConfigMap in Kubernetes

Before installing, use kubectl to create the ConfigMap object in your cluster from the file you just prepared.

kubectl apply -f platform-config.yaml --namespace factorhouse

3. Install the Chart

Install the Helm chart, using --set to reference the name of the ConfigMap you just created. The --create-namespace flag will ensure the target namespace exists.

helm install platform ./factor-platform \
  --set envFromConfigMap=platform-config \
  --create-namespace --namespace factorhouse

The Factor Platform pod will now start using the environment variables from your externally managed ConfigMap.

See platform-config.yaml.example for an example ConfigMap file.

See the Kubernetes documentation on configuring all key-value pairs in a config map as container environment variables for more information.

Manage sensitive environment variables​

This helm chart accepts the name of a secret containing sensitive parameters, e.g.

apiVersion: v1
kind: Secret
metadata:
  name: platform-secrets
data:
  SASL_JAAS_CONFIG: a3JnLmFwYWNoXS5rYWZrYS5jb21tb24uc2VjdXJpdHkucGxhaW4uUGxhaW5Mb2dpbk2vZHVsZSByZXF1aXJiZCB1c2VybmFtZT0iTFQ1V0ZaV1BRWUpHNzRJQyIgcGFzc3dvcmQ9IjlYUFVYS3BLYUQxYzVJdXVNRjRPKzZ2NxJ0a1E4aS9yWUp6YlppdlgvZnNiTG51eGY4SnlFT1dUeXMvTnJ1bTAiBwo=
  CONFLUENT_API_SECRET: NFJSejlReFNTTXlTcGhXdjNLMHNYY1F6UGNURmdadlNYT0ZXSXViWFJySmx2N3A2WStSenROQnVpYThvNG1NSRo=
kubectl apply -f ./platform-secrets.yaml --namespace factorhouse

Then run the helm chart (this can be used in conjunction with envFromConfigMap)

See the Kubernetes documentation on configuring all key value pairs in a secret as environment variables for more information.

helm install platform ./factor-platform \
  --set envFromSecret=platform-secrets \
  --set envFromConfigMap=platform-config \
  --create-namespace --namespace factorhouse

Provide files to the Factor Platform Pod​

There are occasions where you must provide files to the Factor Platform Pod in order for Factor Platform to run correctly, such files include:

  • RBAC configuration
  • SSL Keystores
  • SSL Truststores

How you provide these files is down to user preference, we are not able to provide any support or instruction in this regard.

You may find the Kubernetes documentation on injecting data into applications useful.

Factor Platform memory and CPU requirements​

The chart runs Factor Platform with Guaranteed QoS, having resource request and limit set to these values by default:

resources:
  limits:
    cpu: 2
    memory: 8Gi
  requests:
    cpu: 2
    memory: 8Gi

These default resource settings are conservative and are intended for deployments of the Factor Platform that manage multiple Kafka and Flink clusters along with their associated resources.

If you're running the Factor Platform with a single Kafka and Flink cluster, you can experiment with reducing resource allocations down to our suggested minimum:

Minimum resource requirements​

resources:
  limits:
    cpu: 1
    memory: 2Gi
  requests:
    cpu: 1
    memory: 2Gi

Adjust these values from the command line like so:

helm install platform factorhouse/factor-platform \
     --set resources.limits.cpu=1 \
     --set resources.limits.memory=2Gi \
     --set resources.requests.cpu=1 \
     --set resources.requests.memory=2Gi \
     --create-namespace --namespace factorhouse

We recommend always having limits and requests set to the same value, as this sets Factor Platform's QoS to Guaranteed and provides a much more reliable operation.

Snappy compression in read-only filesystem​

We preset an attribute for Snappy compression in read-only filesystems. It is disabled by default and can be enabled - modify the volume configuration if necessary.

ephemeralTmp:
  enabled: true
  volume:
    emptyDir:
      medium: Memory # Optional: for better performance
      sizeLimit: "100Mi" # Configurable size

Get Help!​

If you have any issues or errors, please contact support@factorhouse.io.