Private Deployment
Configuration Reference

Configuration Reference

This document provides a comprehensive reference for all configuration values in the Rulebricks Helm chart. Values are organized by component with detailed explanations of their purpose, defaults, and recommendations.

Core Configuration

ParameterTypeDefaultRequiredDescription
global.domainstring""YesThe domain name for your Rulebricks instance. Must be a domain you control.
global.emailstring"support@rulebricks.com"YesEmail address for Let's Encrypt certificate registration.
global.licenseKeystring"evaluation"YesYour Rulebricks Enterprise license key.
global.tlsEnabledbooleanfalseNoEnable HTTPS. Set to true after DNS is configured or when using external-dns.
global.externalDnsEnabledbooleanfalseNoEnable external-dns annotations on ingresses for automatic DNS management.

Domain Configuration

Your domain should follow the pattern: rulebricks.yourdomain.com

When self-hosting Supabase, an additional subdomain is created: supabase.rulebricks.yourdomain.com

global:
  domain: 'rulebricks.acme.com'
  email: 'devops@acme.com'
⚠️

Important: The domain must resolve to your cluster's load balancer before enabling TLS. See DNS Configuration for automatic setup.

SMTP Configuration

SMTP is required for user authentication flows (invitations, password resets, email verification).

ParameterTypeDefaultDescription
global.smtp.hoststring"smtp.mailtrap.io"SMTP server hostname
global.smtp.portinteger2525SMTP server port (typically 25, 465, 587, or 2525)
global.smtp.userstring"demo-user"SMTP authentication username
global.smtp.passstring"demo-password"SMTP authentication password
global.smtp.fromstring"no-reply@rulebricks.com"Sender email address
global.smtp.fromNamestring"Rulebricks"Sender display name

Production SMTP Providers

ProviderHostPortNotes
AWS SESemail-smtp.<region>.amazonaws.com587Requires verified domain
SendGridsmtp.sendgrid.net587API key as password
Mailgunsmtp.mailgun.org587Domain verification required
Postmarksmtp.postmarkapp.com587Server token as password
global:
  smtp:
    host: 'email-smtp.us-east-1.amazonaws.com'
    port: 587
    user: 'AKIAIOSFODNN7EXAMPLE'
    pass: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY'
    from: 'no-reply@yourdomain.com'
    fromName: 'Your Company - Rulebricks'

Supabase Keys

These JWT keys are used for authentication between components.

ParameterTypeDescription
global.supabase.anonKeystringPublic/anonymous key for client-side auth
global.supabase.serviceKeystringService role key for server-side operations
global.supabase.jwtSecretstringJWT signing secret (self-hosted only)

Security: For production, generate new keys using Supabase's key generator or a secure random string generator. The default keys are for demo purposes only.

Managed Supabase (Cloud)

When using Supabase Cloud instead of self-hosting:

ParameterTypeDescription
global.supabase.urlstringProject URL (e.g., https://abcd1234.supabase.co)
global.supabase.projectRefstringProject reference ID (derived from URL if empty)
global.supabase.accessTokenstringPersonal access token for Supabase CLI
global:
  supabase:
    url: 'https://abcd1234.supabase.co'
    anonKey: '<from-supabase-dashboard>'
    serviceKey: '<from-supabase-dashboard>'
    accessToken: '<personal-access-token>'
 
supabase:
  enabled: false # Disable self-hosted Supabase

Email Templates

Customize authentication email subjects and templates:

global:
  supabase:
    emails:
      subjects:
        invite: 'Join your team on Rulebricks'
        confirmation: 'Confirm Your Email'
        recovery: 'Reset Your Password'
        emailChange: 'Confirm Email Change'
      templates:
        invite: 'https://your-cdn.com/templates/invite.html'
        confirmation: 'https://your-cdn.com/templates/verify.html'
        recovery: 'https://your-cdn.com/templates/password_change.html'
        emailChange: 'https://your-cdn.com/templates/email_change.html'

AI Features

Enable AI-powered rule generation (optional):

ParameterTypeDefaultDescription
global.ai.enabledbooleanfalseEnable AI features
global.ai.openaiApiKeystring""OpenAI API key
global:
  ai:
    enabled: true
    openaiApiKey: 'sk-...'

SSO Configuration

Enable Single Sign-On (SSO) via OpenID Connect (OIDC).

ParameterTypeDefaultDescription
global.sso.enabledbooleanfalseEnable SSO
global.sso.providerstring""Provider name (azure, google, okta, keycloak, ory, other)
global.sso.urlstring""Provider URL (required for all except Google)
global.sso.clientIdstring""OAuth client ID
global.sso.clientSecretstring""OAuth client secret

Provider Types

You will need to go to your Supabase dashboard, and configure your provider in the Authentication tab. If you don't see your provider, use Keycloak – our proxy uses it as a bridge.

  • Native Providers (azure, google, okta, keycloak): Supabase handles authentication directly.
  • Custom Providers (ory, other): The app uses a built-in OIDC proxy we manage to translate paths for your IdP.

Identity Provider Setup

You must configure your Identity Provider (IdP) with the following settings:

  • Scopes: openid, email, profile
  • Response Type: code
  • Grant Types: authorization_code, refresh_token
  • Auth Method: http body
  • Redirect URIs:
    1. https://<your-domain>/api/sso-proxy/callback
    2. <your-supabase-url>/auth/v1/callback

External Secrets

For enterprise deployments using external secret management:

ParameterTypeDescription
global.secrets.secretRefstringName of existing Kubernetes secret
global.secrets.secretRefKeys.*objectKey name mappings
global:
  secrets:
    secretRef: 'rulebricks-external-secrets'
    secretRefKeys:
      licenseKey: 'RULEBRICKS_LICENSE'
      smtpUser: 'SMTP_USERNAME'
      smtpPass: 'SMTP_PASSWORD'
      supabaseAnonKey: 'SUPABASE_ANON'
      supabaseServiceKey: 'SUPABASE_SERVICE'
      supabaseAccessToken: 'SUPABASE_TOKEN'
      openaiApiKey: 'OPENAI_KEY'

Rulebricks Application

The core application and high-performance solver (HPS).

Application Image

ParameterTypeDefaultDescription
rulebricks.app.image.repositorystring"index.docker.io/rulebricks/app"Docker image repository
rulebricks.app.image.tagstring"1.X.X"Image version tag
rulebricks.app.image.pullPolicystring"IfNotPresent"Image pull policy

Logging Configuration

ParameterTypeDefaultDescription
rulebricks.app.logging.enabledbooleantrueEnable decision logging
rulebricks.app.logging.kafkaBrokersstring""Kafka brokers (auto-discovered if empty)
rulebricks.app.logging.kafkaTopicstring"logs"Kafka topic for logs
rulebricks.app.logging.loggingDestinationstring"Console (stdout)"Display label in UI

Ingress

ParameterTypeDefaultDescription
rulebricks.ingress.enabledbooleantrueEnable ingress
rulebricks.ingress.classNamestring"traefik"Ingress class name
rulebricks.ingress.pathslist[{...}]List of paths to route

Redis

Redis is used for caching and session management.

ParameterTypeDefaultRecommendation
rulebricks.redis.resources.requests.cpustring"200m"Increase for high traffic
rulebricks.redis.resources.requests.memorystring"256Mi"
rulebricks.redis.resources.limits.cpustring"500m"
rulebricks.redis.resources.limits.memorystring"4Gi"Increase for large rule sets
rulebricks.redis.persistence.enabledbooleantrueKeep enabled for production
rulebricks.redis.persistence.sizestring"4Gi"
rulebricks.redis.persistence.storageClassstring"gp3"Match your storage class

High Performance Server (HPS)

HPS handles rule execution with horizontal scaling.

ParameterTypeDefaultDescription
rulebricks.hps.enabledbooleantrueEnable HPS
rulebricks.hps.replicasinteger3Number of HPS gateway replicas
rulebricks.hps.workers.enabledbooleantrueEnable worker pods
rulebricks.hps.workers.replicasinteger4Base worker replica count

HPS Image

ParameterTypeDefaultDescription
rulebricks.hps.image.repositorystring"index.docker.io/rulebricks/hps"Docker image repository
rulebricks.hps.image.tagstring"1.X.X"Image version tag
rulebricks.hps.image.pullPolicystring"Always"Image pull policy

HPS Resources

ParameterTypeDefault
rulebricks.hps.resources.requests.cpustring"1000m"
rulebricks.hps.resources.requests.memorystring"1Gi"
rulebricks.hps.resources.limits.cpustring"2000m"
rulebricks.hps.resources.limits.memorystring"2Gi"

KEDA Autoscaling for HPS Workers

ParameterTypeDefaultDescription
rulebricks.hps.workers.keda.enabledbooleantrueEnable KEDA autoscaling
rulebricks.hps.workers.keda.minReplicaCountinteger4Minimum workers
rulebricks.hps.workers.keda.maxReplicaCountinteger12Maximum workers
rulebricks.hps.workers.keda.pollingIntervalinteger10Seconds between metric checks
rulebricks.hps.workers.keda.cooldownPeriodinteger300Seconds before scale-down
rulebricks.hps.workers.keda.lagThresholdinteger50Kafka lag threshold
rulebricks.hps.workers.keda.cpuThresholdinteger25CPU percentage threshold

Tuning Recommendations:

# High-throughput configuration
# Replicas should match partitions
rulebricks:
  hps:
    replicas: 4
    workers:
      replicas: 8
      keda:
        minReplicaCount: 12
        maxReplicaCount: 32
        lagThreshold: 5
        cpuThreshold: 20

Database (Supabase)

Self-Hosted vs. Managed

Modesupabase.enabledUse Case
Self-hostedtrueFull control, air-gapped environments
Managed (Cloud)falseSimplified operations, managed backups

Self-Hosted Configuration

ParameterTypeDefaultDescription
supabase.enabledbooleantrueDeploy self-hosted Supabase
supabase.secret.db.usernamestring"postgres"Database username
supabase.secret.db.passwordstring"postgres-password-change-me"Change this!
supabase.secret.db.databasestring"postgres"Database name
supabase.secret.dashboard.usernamestring"supabase"Studio dashboard username
supabase.secret.dashboard.passwordstring"dashboard-password-change-me"Change this!

Database Resources

ParameterTypeDefaultProduction Recommendation
supabase.db.resources.requests.cpustring"500m""1000m" or higher
supabase.db.resources.requests.memorystring"1Gi""2Gi" or higher
supabase.db.persistence.enabledbooleantrueAlways true for production
supabase.db.persistence.sizestring"10Gi"Based on data volume
supabase.db.persistence.storageClassNamestring"gp3"Use fast storage

Kong Ingress

ParameterTypeDefaultDescription
supabase.kong.ingress.enabledbooleantrueEnable Supabase API ingress
supabase.kong.ingress.classNamestring"traefik"Must match Traefik class

Message Queue (Kafka)

Kafka handles async rule execution and logging.

Basic Settings

ParameterTypeDefaultDescription
kafka.enabledbooleantrueDeploy Kafka
kafka.kraft.enabledbooleantrueUse KRaft mode (no Zookeeper)
kafka.zookeeper.enabledbooleanfalseDisable Zookeeper

Controller/Broker Configuration

ParameterTypeDefaultDescription
kafka.controller.replicaCountinteger1Number of Kafka nodes
kafka.controller.resources.requests.cpustring"500m"CPU request
kafka.controller.resources.requests.memorystring"2Gi"Memory request
kafka.controller.resources.limits.cpustring"2000m"CPU limit
kafka.controller.resources.limits.memorystring"3Gi"Memory limit
kafka.controller.persistence.sizestring"10Gi"Storage size
kafka.controller.heapOptsstring"-Xmx1g -Xms1g..."JVM heap settings

Kafka Tuning

The default configuration includes extensive JVM and Kafka tuning:

kafka:
  overrideConfiguration:
    auto.create.topics.enable: 'true'
    log.retention.hours: '24' # Adjust based on log volume
    default.replication.factor: '1' # Increase for HA
    offsets.topic.replication.factor: '1'
    num.partitions: '12' # Increase for parallelism
  controller:
    extraEnvVars:
      - name: KAFKA_JVM_PERFORMANCE_OPTS
        value: '-XX:MaxDirectMemorySize=256M -Djdk.nio.maxCachedBufferSize=262144'
      - name: KAFKA_CFG_QUEUED_MAX_REQUESTS
        value: '10000'
      - name: KAFKA_CFG_NUM_NETWORK_THREADS
        value: '8'
      - name: KAFKA_CFG_NUM_IO_THREADS
        value: '8'
      - name: KAFKA_CFG_SOCKET_SEND_BUFFER_BYTES
        value: '1048576'
      - name: KAFKA_CFG_SOCKET_RECEIVE_BUFFER_BYTES
        value: '1048576'
      - name: KAFKA_CFG_SOCKET_REQUEST_MAX_BYTES
        value: '209715200'
      - name: KAFKA_CFG_LOG_RETENTION_BYTES
        value: '4294967296'
      - name: KAFKA_CFG_LOG_SEGMENT_BYTES
        value: '1073741824'
      - name: KAFKA_CFG_NUM_REPLICA_FETCHERS
        value: '4'
      - name: KAFKA_CFG_REPLICA_SOCKET_RECEIVE_BUFFER_BYTES
        value: '1048576'
      - name: KAFKA_CFG_LOG_CLEANER_DEDUPE_BUFFER_SIZE
        value: '268435456'
      - name: KAFKA_CFG_LOG_CLEANER_IO_BUFFER_SIZE
        value: '1048576'
      - name: KAFKA_CFG_MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION
        value: '10'
  listeners:
    client:
      protocol: PLAINTEXT
    controller:
      protocol: PLAINTEXT
    interbroker:
      protocol: PLAINTEXT

High-Availability Configuration:

kafka:
  controller:
    replicaCount: 3
  overrideConfiguration:
    default.replication.factor: '3'
    min.insync.replicas: '2'

Ingress (Traefik)

Traefik handles all incoming traffic and TLS termination.

ParameterTypeDefaultDescription
traefik.enabledbooleantrueDeploy Traefik
traefik.ingressClass.namestring"traefik"Ingress class name
traefik.autoscaling.enabledbooleantrueEnable HPA
traefik.autoscaling.minReplicasinteger1Minimum replicas
traefik.autoscaling.maxReplicasinteger2Maximum replicas

Resources

ParameterTypeDefaultHigh-Traffic
traefik.resources.requests.cpustring"100m""500m"
traefik.resources.requests.memorystring"256Mi""512Mi"
traefik.resources.limits.cpustring"1000m""2000m"
traefik.resources.limits.memorystring"2Gi""4Gi"

Ports

ParameterDefaultDescription
traefik.ports.web.port8000Internal HTTP port
traefik.ports.web.exposedPort80External HTTP port
traefik.ports.websecure.port8443Internal HTTPS port
traefik.ports.websecure.exposedPort443External HTTPS port

Persistence

ParameterTypeDefaultDescription
traefik.persistence.enabledbooleanfalseEnable persistence

Autoscaling (KEDA)

KEDA provides event-driven autoscaling for HPS workers.

ParameterTypeDefaultDescription
keda.enabledbooleantrueDeploy KEDA
keda.crds.installbooleanfalseCRDs managed by parent chart

Note: KEDA CRDs are included in the crds/ directory and installed automatically.

Certificates (cert-manager)

cert-manager provisions TLS certificates from Let's Encrypt.

ParameterTypeDefaultDescription
cert-manager.enabledbooleantrueDeploy cert-manager
cert-manager.installCRDsbooleanfalseCRDs managed by parent chart

The chart creates:

  • A ClusterIssuer for Let's Encrypt production
  • Certificate resources for your domain(s)

Logging (Vector)

Vector aggregates logs from Kafka and forwards them to configured sinks.

ParameterTypeDefaultDescription
vector.enabledbooleantrueDeploy Vector
vector.rolestring"Stateless-Aggregator"Vector role
vector.replicasinteger2Number of replicas

Resources

ParameterTypeDefault
vector.resources.requests.cpustring"50m"
vector.resources.requests.memorystring"128Mi"
vector.resources.limits.cpustring"200m"
vector.resources.limits.memorystring"256Mi"

Service

ParameterTypeDefaultDescription
vector.service.enabledbooleantrueEnable Vector service
vector.service.portslist[{...}]Service ports

Environment Variables

ParameterTypeDefaultDescription
vector.envlist[{...}]Environment variables (e.g., KAFKA_BOOTSTRAP_SERVERS)

Custom Sinks

Configure log destinations in vector.customConfig.sinks:

vector:
  customConfig:
    sources:
      kafka:
        type: kafka
        bootstrap_servers: '${KAFKA_BOOTSTRAP_SERVERS:-rulebricks-kafka:9092}'
        topics:
          - logs
        group_id: vector-consumers
        auto_offset_reset: latest
    sinks:
      # Console output (default)
      console:
        type: console
        inputs: [kafka]
        encoding:
          codec: json
 
      # S3 sink example
      s3:
        type: aws_s3
        inputs: [kafka]
        bucket: 'your-logs-bucket'
        region: 'us-east-1'
        key_prefix: 'rulebricks/logs/%Y/%m/%d/'
        compression: gzip
        encoding:
          codec: json

DNS (external-dns)

external-dns automatically creates DNS records for your ingresses.

ParameterTypeDefaultDescription
external-dns.enabledbooleanfalseDeploy external-dns
external-dns.providerstring"route53"DNS provider
external-dns.sourceslist["ingress"]Resource types to watch
external-dns.domainFilterslist[]Restrict to specific domains
external-dns.policystring"upsert-only"Record management policy

Provider Configuration

AWS Route53

external-dns:
  enabled: true
  provider: route53
  # Uses IRSA - ensure service account has Route53 permissions

Cloudflare

external-dns:
  enabled: true
  provider: cloudflare
  extraEnvVars:
    - name: CF_API_TOKEN
      valueFrom:
        secretKeyRef:
          name: cloudflare-api-token
          key: api-token

Google Cloud DNS

external-dns:
  enabled: true
  provider: google
  google:
    project: 'your-gcp-project'

Azure DNS

external-dns:
  enabled: true
  provider: azure
  azure:
    resourceGroup: 'your-resource-group'
    subscriptionId: 'your-subscription-id'

Monitoring (Prometheus)

Optional Prometheus stack for metrics collection.

ParameterTypeDefaultDescription
monitoring.enabledbooleanfalseEnable monitoring
kube-prometheus-stack.alertmanager.enabledbooleanfalseDeploy Alertmanager
kube-prometheus-stack.grafana.enabledbooleanfalseDeploy Grafana

Prometheus Storage

kube-prometheus-stack:
  prometheus:
    prometheusSpec:
      retention: 30d
      storageSpec:
        volumeClaimTemplate:
          spec:
            storageClassName: gp3
            resources:
              requests:
                storage: 50Gi

Storage

StorageClass

The chart can create a gp3 StorageClass for AWS EBS:

ParameterTypeDefaultDescription
storageClass.createbooleantrueCreate StorageClass
storageClass.namestring"gp3"StorageClass name
storageClass.provisionerstring"ebs.csi.aws.com"CSI provisioner
storageClass.typestring"gp3"EBS volume type
storageClass.fsTypestring"ext4"File system type
storageClass.reclaimPolicystring"Delete"Reclaim policy
storageClass.volumeBindingModestring"WaitForFirstConsumer"Binding mode
storageClass.allowVolumeExpansionbooleantrueAllow expansion

For non-AWS clusters, set storageClass.create: false and ensure a compatible StorageClass exists.