rondb-helm

Usage

Helm must be installed to use the charts. Please refer to Helm’s documentation to get started.

Once Helm has been set up correctly, add the repo as follows:

helm repo add rondb https://logicalclocks.github.io/rondb-helm/

If you had already added this repo earlier, run helm repo update to retrieve the latest versions of the packages. You can then run helm search repo rondb to see the charts.

To install the rondb chart:

helm install my-rondb rondb/rondb

To uninstall the chart:

helm delete my-rondb

Values options

This has been auto-generated from the values.schema.json file.

Chart version is 26.2.22. See commit history for previous schemata.

Field Path	Type	Description	Default
backups	object	Whether, how and how often to run regular backups on the cluster
backups.enabled	[‘boolean’, ‘null’]
backups.metadataConfigmapName	[‘string’, ‘null’]	The name of the configmap to be used to store the backups metadata information.
backups.objectStorageProvider	enum: [s3]		s3
backups.pathPrefix	string	Prefix of RonDB backup in the configured bucket	rondb_backup
backups.s3	object
backups.s3.bucketName	[‘string’, ‘null’]
backups.s3.endpoint	[‘string’, ‘null’]
backups.s3.keyCredentialsSecret	object
backups.s3.keyCredentialsSecret.key	[‘string’, ‘null’]	Key in the Secret
backups.s3.keyCredentialsSecret.name	[‘string’, ‘null’]	Name of the Secret
backups.s3.provider	[‘string’, ‘null’]
backups.s3.region	[‘string’, ‘null’]
backups.s3.secretCredentialsSecret	object
backups.s3.secretCredentialsSecret.key	[‘string’, ‘null’]	Key in the Secret
backups.s3.secretCredentialsSecret.name	[‘string’, ‘null’]	Name of the Secret
backups.s3.serverSideEncryption	enum: [aws:kms, aws:kms:dsse, AES256, null]
backups.schedule	[‘string’, ‘null’]	Cron schedule for backups
backups.ttl	[‘string’, ‘null’]	time to live to control when to clean up backups. It is a number followed by either d (days) or h (hours) suffix.
benchmarking	object	Whether, which and how to run a benchmarking job on the cluster
benchmarking.dbt2	object	Configuration of DBT2 benchmarking job
benchmarking.dbt2.numWarehouses	integer		4
benchmarking.dbt2.runMulti	string	Table with columns: NUM_MYSQL_SERVERS, NUM_WAREHOUSES, NUM_TERMINALS	# NUM_MYSQL_SERVERS NUM_WAREHOUSES NUM_TERMINALS
			2 1 1
			2 2 1
			2 2 2
benchmarking.dbt2.runSingle	string	Table with columns: NUM_MYSQL_SERVERS, NUM_WAREHOUSES, NUM_TERMINALS	# NUM_MYSQL_SERVERS NUM_WAREHOUSES NUM_TERMINALS
			1 1 1
			1 2 1
			1 4 1
			1 4 2
benchmarking.enabled	boolean	Whether to run a benchmarking job on the cluster	False
benchmarking.sysbench	object	Configuration of Sysbench benchmarking job
benchmarking.sysbench.minimizeBandwidth	boolean	Whether to use filters to minimize bandwidth usage. This can be useful in cloud environments where bandwidth is expensive.	False
benchmarking.sysbench.rows	integer		100000
benchmarking.sysbench.threadCountsToRun	string	Semi-colon-separated list of thread counts to run	1;2;4;8;12;16;24;32;64
benchmarking.type	enum: [sysbench, dbt2_single, dbt2_multi, ycsb]	Which benchmarking job to run. ‘Multi’ refers to multiple MySQLd servers to run against	sysbench
benchmarking.ycsb	object	Configuration of YCSB benchmarking job
benchmarking.ycsb.schemata	string	MySQL table schema to use for YCSB. NOTE: The ycsb database is pre-created.	CREATE TABLE IF NOT EXISTS ycsb.usertable (YCSB_KEY VARCHAR(255) PRIMARY KEY, FIELD0 varbinary(4096));
clusterSize	object	Horizontal cluster size
clusterSize.activeDataReplicas	integer	How many replicas each node group has. When descreasing this value, try going down by 1 at a time. Too many nodes leaving at once can cause issues with leader elections.	2
clusterSize.maxNumMySQLServers	integer	The maximum amount of MySQL servers we will auto-scale to. It is represented as number of slots in RonDB’s config.ini. Changing this will only take effect if the ConfigMap for config.ini is updated and the MGMd is restarted.	5
clusterSize.maxNumRdrs	integer		2
clusterSize.minNumMySQLServers	integer	A minimum amount of MySQL servers	1
clusterSize.minNumRdrs	integer		1
clusterSize.numNodeGroups	integer	Number of RonDB node groups. Immutable after install — RonDB has no online add/remove. Changing it requires uninstall and reinstall with restoreFromBackup.backupId. Set mode: upgrade for ArgoCD or other template-only renderers so the immutability check runs as an in-cluster Job.	1
createPriorityClass	boolean	Flag to disable the creation of PriorityClass in case it was created beforehand	True
enableSecurityContext	boolean		True
forceNodeGroupChange	boolean	Skip the pre-upgrade immutability gate on clusterSize.numNodeGroups. RonDB still cannot add or remove node groups online, so an upgrade that changes numNodeGroups under this flag will break the cluster.	False
globalReplication	object
globalReplication.clusterNumber	number	Determines the offset for global server IDs	1
globalReplication.primary	object
globalReplication.primary.binlogFilename	string		binlog
globalReplication.primary.enabled	boolean	Specifies if the primary replication is enabled. This will actually create the binary log servers. Can be activated after an initial start.	False
globalReplication.primary.expireBinlogsDays	number		1.5
globalReplication.primary.ignoreDatabases	array		[]
globalReplication.primary.includeDatabases	array		[]
globalReplication.primary.logReplicaUpdates	boolean		False
globalReplication.primary.maxNumBinlogServers	number	Don’t change this value. Determines how many binlog servers we can scale out to. Used to determine the server IDs for global replication. Even if replication is disabled, potential binlog servers will be written into the config.ini.	2
globalReplication.primary.numBinlogServers	number	The current number of binlog servers, given global Replication is enabled.	2
globalReplication.secondary	object
globalReplication.secondary.enabled	boolean		False
globalReplication.secondary.replicateFrom	object	RonDB clusters to replicate from. RonDB supports merge-replicating from multiple clusters, but we only support replicating from one cluster
globalReplication.secondary.replicateFrom.binlogServerHosts	array	Hostnames of the binlog server to replicate from. The binlog servers have headless ClusterIPs and one LoadBalancer per binlog server. If we replicate across different K8s clusters, we can reference the External IPs of the binlog servers’ LoadBalancers here.	[]
globalReplication.secondary.replicateFrom.clusterNumber	number	A helper to understand from which serverIds to replicate from	2
globalReplication.secondary.replicateFrom.ignoreDatabases	array		[]
globalReplication.secondary.replicateFrom.ignoreTables	array		[]
globalReplication.secondary.replicateFrom.includeDatabases	array		[]
globalReplication.secondary.replicateFrom.includeTables	array		[]
globalReplication.secondary.replicateFrom.useTlsConnection	boolean	Enable this for an encrypted replication channel. Important if the binlog server requires TLS connections	False
imagePullPolicy	string	The Kubernetes image pull policy	IfNotPresent
imagePullSecrets	array		[]
images	object	Information for Docker images used in the cluster
images.dataValidation	object
images.dataValidation.name	string		python
images.dataValidation.registry	string		docker.io
images.dataValidation.repository	string
images.dataValidation.tag	string		3.12-slim
images.mysqldExporter	object
images.mysqldExporter.name	string		mysqld_exporter
images.mysqldExporter.registry	string		docker.hops.works
images.mysqldExporter.repository	string		hopsworks
images.mysqldExporter.tag	string		0.11.5
images.rondb	object
images.rondb.name	string		rondb
images.rondb.registry	string		docker.io
images.rondb.repository	string		hopsworks
images.rondb.tag	string	The version of RonDB to use; This should always be equivalent to .Chart.AppVersion	26.02.12
images.toolbox	object
images.toolbox.name	string		hwutils
images.toolbox.registry	string		docker.io
images.toolbox.repository	string		hopsworks
images.toolbox.tag	string		1.7
images.upgrade2410revokegrants	object
images.upgrade2410revokegrants.name	string		rondb
images.upgrade2410revokegrants.registry	string		docker.io
images.upgrade2410revokegrants.repository	string		hopsworks
images.upgrade2410revokegrants.tag	string	The version of RonDB to use when revoking bogus user privilege to upgrade from 22.10 to 24.10	22.10.13-0.7
isMultiNodeCluster	boolean	Whether the Kubernetes cluster has multiple nodes; this will affect affinities and add requirements to scheduling.	True
meta	object
meta.binlogServers	object
meta.binlogServers.externalLoadBalancers	object	One LoadBalancer per binlog server; Creating an (alternative) Ingress per binlog server is difficult
meta.binlogServers.externalLoadBalancers.annotations	object	Cloud provider load balancer specific annotations.	{}
meta.binlogServers.externalLoadBalancers.class	[‘string’, ‘null’]
meta.binlogServers.externalLoadBalancers.enabled	boolean		True
meta.binlogServers.externalLoadBalancers.namePrefix	string		binlog-server
meta.binlogServers.externalLoadBalancers.port	integer	Port to expose the service on	3306
meta.binlogServers.headlessClusterIp	object
meta.binlogServers.headlessClusterIp.name	string		headless-binlog-servers
meta.binlogServers.headlessClusterIp.port	integer		3306
meta.binlogServers.statefulSet	object
meta.binlogServers.statefulSet.endToEndTls	object
meta.binlogServers.statefulSet.endToEndTls.enabled		Whether to use end-to-end encryption for MySQL binlog server Pods. This is recommended for high-security use cases. For MySQLds this is especially recommended since they use raw TCP connections and thereby by-pass TLS Ingress-rules. Otherwise, Ingress-TCP can also be configured directly via the Ingress controller (not in this Helmchart).	False
meta.binlogServers.statefulSet.endToEndTls.filenames	object
meta.binlogServers.statefulSet.endToEndTls.filenames.ca	[‘string’, ‘null’]	Name of the CA file in the Secret. ONLY overwrite this if you’re not using standard TLS Secrets.
meta.binlogServers.statefulSet.endToEndTls.filenames.cert	string	Name of the certificate file in the Secret. ONLY overwrite this if you’re not using standard TLS Secrets.	tls.crt
meta.binlogServers.statefulSet.endToEndTls.filenames.key	string	Name of the key file in the Secret. ONLY overwrite this if you’re not using standard TLS Secrets.	tls.key
meta.binlogServers.statefulSet.endToEndTls.secretName	string	Name of the TLS Secret	binlog-end-to-end-tls
meta.binlogServers.statefulSet.endToEndTls.supplyOwnSecret		Whether the Helmchart user will create a TLS Secret outside of this Helmchart. Otherwise we rely on cert-manager to create one.	False
meta.binlogServers.statefulSet.name	string		mysqld-binlog-servers
meta.ddlMySQLd	object
meta.ddlMySQLd.addSysNiceCapability	boolean		True
meta.ddlMySQLd.clusterIp	object
meta.ddlMySQLd.clusterIp.annotations	object		{}
meta.ddlMySQLd.clusterIp.name	string		ddl-mysqld
meta.ddlMySQLd.clusterIp.port	integer		3306
meta.ddlMySQLd.enabled	boolean	Whether to deploy the DDL MySQLd StatefulSet and reserve its NDB node slot.	False
meta.ddlMySQLd.headlessClusterIp	object
meta.ddlMySQLd.headlessClusterIp.name	string		headless-ddl-mysqld
meta.ddlMySQLd.headlessClusterIp.port	integer		3306
meta.ddlMySQLd.statefulSet	object
meta.ddlMySQLd.statefulSet.endToEndTls	object
meta.ddlMySQLd.statefulSet.endToEndTls.enabled	boolean	Whether to use end-to-end encryption for DDL MySQL server Pods.	False
meta.ddlMySQLd.statefulSet.endToEndTls.filenames	object
meta.ddlMySQLd.statefulSet.endToEndTls.filenames.ca	[‘string’, ‘null’]	Name of the CA file in the Secret. ONLY overwrite this if you’re not using standard TLS Secrets.
meta.ddlMySQLd.statefulSet.endToEndTls.filenames.cert	string	Name of the certificate file in the Secret. ONLY overwrite this if you’re not using standard TLS Secrets.	tls.crt
meta.ddlMySQLd.statefulSet.endToEndTls.filenames.key	string	Name of the key file in the Secret. ONLY overwrite this if you’re not using standard TLS Secrets.	tls.key
meta.ddlMySQLd.statefulSet.endToEndTls.secretName	string	Name of the TLS Secret	ddl-mysqld-end-to-end-tls
meta.ddlMySQLd.statefulSet.endToEndTls.supplyOwnSecret	boolean	Whether the Helmchart user will create a TLS Secret outside of this Helmchart. Otherwise we rely on cert-manager to create one.	False
meta.ddlMySQLd.statefulSet.name	string		ddl-mysqld
meta.mgmd	object
meta.mgmd.headlessClusterIp	object
meta.mgmd.headlessClusterIp.annotations	object		{}
meta.mgmd.headlessClusterIp.name	string		headless-mgmds
meta.mgmd.headlessClusterIp.port	integer		1186
meta.mgmd.statefulSetName	string		mgmds
meta.mysqld	object
meta.mysqld.addSysNiceCapability	boolean		True
meta.mysqld.clusterIp	object
meta.mysqld.clusterIp.annotations	object		{}
meta.mysqld.clusterIp.name	string		mysqld
meta.mysqld.clusterIp.port	integer		3306
meta.mysqld.exporter	object	Configuration for mysqld exporter
meta.mysqld.exporter.metricsPort	integer		9104
meta.mysqld.externalLoadBalancer	object	Configuration for load balancer service to be used for external access
meta.mysqld.externalLoadBalancer.annotations	object	Cloud provider load balancer specific annotations.	{}
meta.mysqld.externalLoadBalancer.class	[‘string’, ‘null’]
meta.mysqld.externalLoadBalancer.enabled	boolean		False
meta.mysqld.externalLoadBalancer.managed	boolean	LoadBalancer is managed by provider	True
meta.mysqld.externalLoadBalancer.name	string		mysqld-external
meta.mysqld.externalLoadBalancer.nodePort	[‘integer’, ‘null’]	Explicit nodePort for the service when the load balancer is unmanaged (managed: false), so a load balancer outside Kubernetes can target a fixed port. Null lets Kubernetes allocate one from the cluster’s node-port range.
meta.mysqld.externalLoadBalancer.nodeSelector	object	selector for nodes the load balancer can use to route traffic	{}
meta.mysqld.externalLoadBalancer.port	integer	Port to expose the service on	3306
meta.mysqld.headlessClusterIp	object
meta.mysqld.headlessClusterIp.name	string		headless-mysqlds
meta.mysqld.headlessClusterIp.port	integer		3306
meta.mysqld.statefulSet	object
meta.mysqld.statefulSet.endToEndTls	object
meta.mysqld.statefulSet.endToEndTls.enabled		Whether to use end-to-end encryption for MySQLd Pods. This is recommended for high-security use cases. For MySQLds this is especially recommended since they use raw TCP connections and thereby by-pass TLS Ingress-rules. Otherwise, Ingress-TCP can also be configured directly via the Ingress controller (not in this Helmchart).	False
meta.mysqld.statefulSet.endToEndTls.filenames	object
meta.mysqld.statefulSet.endToEndTls.filenames.ca	[‘string’, ‘null’]	Name of the CA file in the Secret. ONLY overwrite this if you’re not using standard TLS Secrets.
meta.mysqld.statefulSet.endToEndTls.filenames.cert	string	Name of the certificate file in the Secret. ONLY overwrite this if you’re not using standard TLS Secrets.	tls.crt
meta.mysqld.statefulSet.endToEndTls.filenames.key	string	Name of the key file in the Secret. ONLY overwrite this if you’re not using standard TLS Secrets.	tls.key
meta.mysqld.statefulSet.endToEndTls.secretName	string	Name of the TLS Secret	mysqld-end-to-end-tls
meta.mysqld.statefulSet.endToEndTls.supplyOwnSecret		Whether the Helmchart user will create a TLS Secret outside of this Helmchart. Otherwise we rely on cert-manager to create one.	False
meta.mysqld.statefulSet.name	string		mysqlds
meta.ndbmtd	object
meta.ndbmtd.statefulSet	object
meta.ndbmtd.statefulSet.podAnnotations	object		{}
meta.rdrs	object
meta.rdrs.clusterIp	object
meta.rdrs.clusterIp.annotations	object		{‘consul.hashicorp.com/service-name’: ‘rdrs’, ‘prometheus.io/path’: ‘/metrics’, ‘prometheus.io/port’: ‘4406’, ‘prometheus.io/scheme’: ‘https’, ‘prometheus.io/scrape’: ‘true’}
meta.rdrs.clusterIp.name	string		rdrs
meta.rdrs.externalLoadBalancer	object	Configuration for load balancer service to be used for external access
meta.rdrs.externalLoadBalancer.annotations	object	Cloud provider load balancer specific annotations.	{}
meta.rdrs.externalLoadBalancer.class	[‘string’, ‘null’]
meta.rdrs.externalLoadBalancer.enabled	boolean		False
meta.rdrs.externalLoadBalancer.managed	boolean	LoadBalancer is managed by provider	True
meta.rdrs.externalLoadBalancer.name	string		rdrs-external
meta.rdrs.externalLoadBalancer.nodePort	[‘integer’, ‘null’]	Explicit nodePort for the service when the load balancer is unmanaged (managed: false), so a load balancer outside Kubernetes can target a fixed port. Null lets Kubernetes allocate one from the cluster’s node-port range.
meta.rdrs.externalLoadBalancer.nodeSelector	object	selector for nodes the load balancer can use to route traffic	{}
meta.rdrs.headlessClusterIpName	string		rdrs-cluster-ip
meta.rdrs.ingress	object	Configuration of Ingress for RDRS
meta.rdrs.ingress.class	string		nginx
meta.rdrs.ingress.dnsNames	array		[]
meta.rdrs.ingress.enabled	boolean		False
meta.rdrs.ingress.tls	object
meta.rdrs.ingress.tls.enabled	boolean	WARN: Nginx-ingress will always use encryption even if this is disabled. By enabling this, we simply have more control over the TLS Secret. The TLS Secrets are placed onto the Ingress controller instance. Ingress TLS is currently only supported with cert-manager (RonDB-standalone)	True
meta.rdrs.ingress.tls.ipAddresses	array		[]
meta.rdrs.ingress.useDefaultBackend	boolean	Whether to use the RDRS as a default backend for the Ingress; this makes it reachable without specifying a subdomain; i.e. an IP can be used instead.	True
meta.rdrs.statefulSet	object
meta.rdrs.statefulSet.endToEndTls	object
meta.rdrs.statefulSet.endToEndTls.enabled		Whether to use end-to-end encryption for RDRS Pods. This is recommended for high-security use cases.	False
meta.rdrs.statefulSet.endToEndTls.filenames	object
meta.rdrs.statefulSet.endToEndTls.filenames.ca	[‘string’, ‘null’]	Name of the CA file in the Secret. ONLY overwrite this if you’re not using standard TLS Secrets.
meta.rdrs.statefulSet.endToEndTls.filenames.cert	string	Name of the certificate file in the Secret. ONLY overwrite this if you’re not using standard TLS Secrets.	tls.crt
meta.rdrs.statefulSet.endToEndTls.filenames.key	string	Name of the key file in the Secret. ONLY overwrite this if you’re not using standard TLS Secrets.	tls.key
meta.rdrs.statefulSet.endToEndTls.secretName	string	Name of the TLS Secret	rdrs-end-to-end-tls
meta.rdrs.statefulSet.endToEndTls.supplyOwnSecret		Whether the Helmchart user will create a TLS Secret outside of this Helmchart. Otherwise we rely on cert-manager to create one.	False
meta.rdrs.statefulSet.name	string		rdrs
meta.replicaAppliers	object
meta.replicaAppliers.headlessClusterIp	object
meta.replicaAppliers.headlessClusterIp.name	string		headless-replica-appliers
meta.replicaAppliers.headlessClusterIp.port	integer		3306
meta.replicaAppliers.statefulSet	object
meta.replicaAppliers.statefulSet.endToEndTls	object
meta.replicaAppliers.statefulSet.endToEndTls.enabled		Whether to use end-to-end encryption for MySQL replica applier Pods. This is recommended for high-security use cases. For MySQLds this is especially recommended since they use raw TCP connections and thereby by-pass TLS Ingress-rules. Otherwise, Ingress-TCP can also be configured directly via the Ingress controller (not in this Helmchart).	False
meta.replicaAppliers.statefulSet.endToEndTls.filenames	object
meta.replicaAppliers.statefulSet.endToEndTls.filenames.ca	[‘string’, ‘null’]	Name of the CA file in the Secret. ONLY overwrite this if you’re not using standard TLS Secrets.
meta.replicaAppliers.statefulSet.endToEndTls.filenames.cert	string	Name of the certificate file in the Secret. ONLY overwrite this if you’re not using standard TLS Secrets.	tls.crt
meta.replicaAppliers.statefulSet.endToEndTls.filenames.key	string	Name of the key file in the Secret. ONLY overwrite this if you’re not using standard TLS Secrets.	tls.key
meta.replicaAppliers.statefulSet.endToEndTls.secretName	string	Name of the TLS Secret	replica-applier-end-to-end-tls
meta.replicaAppliers.statefulSet.endToEndTls.supplyOwnSecret		Whether the Helmchart user will create a TLS Secret outside of this Helmchart. Otherwise we rely on cert-manager to create one.	False
meta.replicaAppliers.statefulSet.name	string		mysqld-replica-appliers
mgmdPreUpgradeRolloutTimeout	string	Timeout for kubectl rollout status inside the MGMd pre-upgrade hook (per attempt). Default 5m. Note: Helm’s default helm upgrade --timeout is also 5m and bounds the whole upgrade including this hook — operators running with that default may see Helm’s outer timeout fire first with a generic ‘timed out waiting for the condition’ message instead of this hook’s specific diagnostic. Set Helm’s --timeout higher (e.g. 15m) on slow networks or large image pulls.	5m
mode	enum: [install, upgrade, auto, null]	Mode of operation for the Helmchart. ‘install’ will always treat the deployment as a new installation, ‘upgrade’ will always treat it as an upgrade. ‘auto’ will treat it as an install if no previous release is found, otherwise as an upgrade. This flag is unset by default. When specified, it takes precedence over the value defined in .Values.global._hopsworks.mode
mysql	object	How to initialize MySQL
mysql.clusterUser	string	The MySQL user for K8s probes, benchmarks and for the standard my.cnf file.	helm
mysql.config	object	MySQL configuration options
mysql.config.maxConnectErrors	string	Maximum number of connection errors before the MySQL server blocks the host.	9223372036854775807
mysql.config.maxConnections	integer	Maximum number of connections to the MySQL server.	512
mysql.config.maxPreparedStmtCount	integer	Maximum number of prepared statements.	65530
mysql.credentialsSecretName	string	Secret name for MySQL users’ passwords	mysql-passwords
mysql.exporter	object	MySQL exporter configuration
mysql.exporter.enabled	boolean		False
mysql.exporter.maxOpenConnections	integer	Maximum number of open connections to the database per scrape. 1 (default) serializes all collectors onto a single connection; higher values let independent collectors run concurrently but may incur higher load on the database. Should not exceed maxUserConnections.	1
mysql.exporter.maxUserConnections	integer		3
mysql.exporter.username	string		exporter
mysql.force2410UserGrantMigration	boolean	Whether to force the execution of the 24.10 user privilege migration job that revokes the SET_USER_ID privilege from users that should not have it. This is useful when the automatic detection fails.	False
mysql.sqlInitContent	object	SQL to run only once at cluster startup. Try to make these scripts idempotent, in case they are re-run by accident. Do so by e.g. using IF NOT EXISTS in the SQL commands.	{}
mysql.supplyOwnSecret	boolean	If set to false, the Helmchart will auto-generate MySQL passwords. When running Global Replication as a secondary cluster, this should be set to true. Otherwise, the replication of ALTER root password will fail the cluster.	False
mysql.users	array	A list of MySQL users and their privileges.	[]
ndbmtdSequencedRollout	object	Sequenced (one node group at a time) data node rollouts during upgrades. When enabled, the node-group StatefulSets render updateStrategy.rollingUpdate.partition equal to their replica count, so ‘helm upgrade’ lands new pod templates without restarting anything; a rollout CronJob then unfreezes one node group at a time, waiting for each to converge (all pods on the new revision and ready) before the next. This bounds upgrade exposure to a single node group and stops a bad rollout at the first group. Only takes effect with more than one node group (clusterSize.numNodeGroups > 1): with a single group there is nothing to sequence across and the chart behaves exactly as if disabled. Not applied during in-place restores or on externally managed clusters. Argo CD users with selfHeal enabled must add ignoreDifferences for .spec.updateStrategy.rollingUpdate.partition on node-group-* StatefulSets.
ndbmtdSequencedRollout.enabled	boolean	Enable the partition freeze and the rollout CronJob (they always render together). With this on, a successful ‘helm upgrade’ means the new specs are recorded and the rollout is in progress; completion is observable on the StatefulSets (updateRevision == currentRevision on every node group) rather than in the release status. Disabling the flag removes the partition field, so any still-pending update then rolls all node groups concurrently (the pre-feature behavior) - disable during a quiet period or after confirming no update is pending.	False
ndbmtdSequencedRollout.perGroupStallTimeoutMinutes	integer	Minutes an unfrozen node group may stay unconverged before the rollout CronJob reports a stall (logged on every run) and pauses; no further groups are unfrozen while the stalled group keeps trying. Note the next ‘helm upgrade’ (e.g. a fixed image) re-freezes every group, the stalled one included (Helm restores the rendered partition over the live value); the CronJob then delivers the fix by unfreezing the broken group again on the next run, in preference to healthy ones, and the StatefulSet controller replaces its dead pod. This is an alerting threshold - nothing is killed when it fires. 0 derives it from activeDataReplicas x timeoutsMinutes.ndbmtdStartupProbe plus 30 minutes slack.	0
ndbmtdSequencedRollout.reconcileIntervalMinutes	integer	How often the rollout CronJob runs, in minutes. Each run re-freezes converged node groups and unfreezes at most one pending group, so this adds at most one interval of latency per node-group boundary - noise against recovery times measured in hours.	3
ndbmtdSequencedRollout.suspendWhenIdle	boolean	When a run finds every node group converged and frozen, the rollout CronJob suspends itself so nothing at all runs while idle. Any ‘helm upgrade’ or ‘helm rollback’ turns it back on: the chart renders suspend: false and Helm resets live fields to their rendered values. Only takes effect when ‘mode’ is unset or ‘auto’ (plain Helm or Flux); when ‘mode’ is set - the Argo CD convention - the CronJob stays always-on, because Argo’s sync would either keep re-enabling it (saving nothing) or, with ignoreDifferences on the CronJob’s .spec.suspend, never re-enable it. WARNING: while suspended, a node-group spec change applied outside Helm (plain kubectl) stays frozen until the next helm operation or a manual wake: kubectl patch cronjob rondb-ndbmtd-sequenced-rollout –type merge -p ‘{“spec”:{“suspend”:false}}’. Pair with a revision-age alert (kube_statefulset_status_update_revision != kube_statefulset_status_current_revision with an age threshold) as the safety net. Set false to keep the CronJob always running.	True
ndbmtdSettleWait	object	Pre-start settle wait for data nodes, protecting rolling restarts. During a roll, Kubernetes deletes a node group’s second pod only after observing the first replacement Ready; that observation spread (measured 2.6-10.4s and set by the kubelet/API-server publication cycle, which the chart cannot tune) can overlap the window in which an earlier replacement has connected to the cluster but not yet reached the phase-110 restart barrier, killing it with error 2308 (‘Another node failed during system restart’). Before starting the kernel on a non-initial start, the entrypoint polls the MGMd once a second and proceeds only once no data node has departed the cluster for quietSeconds (nodes reconnecting do not reset the timer: only a departing peer endangers a climbing node, and during a round every replacement’s reconnect would otherwise extend the wait to its cap), so the node begins its climb only after the deletion wave has passed. The wait is bounded by maxWaitSeconds and never blocks a start: an unreachable or hanging MGMd degrades to a fixed fallbackSeconds sleep. Skipped entirely on initial starts.
ndbmtdSettleWait.fallbackSeconds	integer	Fixed sleep used instead of the adaptive wait when the MGMd never answers: 3 consecutive failed probes (unreachable, hanging, or empty output) with no successful probe in this wait. A transient MGMd outage after a successful probe does not trigger the fallback - the wait keeps retrying under maxWaitSeconds, with failed probes resetting the quiet timer.	15
ndbmtdSettleWait.maxWaitSeconds	integer	Cap on the whole settle wait, including the final quietSeconds of quiet. 0 disables the settle wait entirely.	30
ndbmtdSettleWait.probeTimeoutSeconds	integer	Timeout for each ndb_mgm membership probe.	5
ndbmtdSettleWait.quietSeconds	integer	Seconds without any data-node departure before the node starts (arrivals are ignored). Must exceed the largest gap between consecutive pod deletions within a rollout round, or the wait provides no protection. The default of 8 is calibrated to ONE measured cluster (max 7.4s gap over 66 rolls at 10 node groups on MicroK8s); the gap is set by the control plane’s readiness-observation latency, not by RonDB, so it MUST be re-derived on a different control plane, larger cluster, or slower hardware - measure the deletion-timestamp gaps within one rollout round and set this above the maximum.	8
networkPolicy	object
networkPolicy.mgmds	object
networkPolicy.mgmds.enabled	boolean	Whether to limit ingress for MGMd pods	True
networkPolicy.mgmds.ingressSelectors	array		[]
networkPolicy.ndbmtds	object
networkPolicy.ndbmtds.enabled	boolean	Whether to limit ingress for data node pods. If there is an empty API slot in the config.ini, any host can connect to them.	True
networkPolicy.ndbmtds.ingressSelectors	array		[]
nodeSelector	object	This ensures that Kubernetes schedules pods only onto nodes that match all the specified labels.
nodeSelector.backup	object		{}
nodeSelector.mgmd	object		{}
nodeSelector.mysqld	object		{}
nodeSelector.ndbmtd	object		{}
nodeSelector.rdrs	object		{}
podDisruptionBudget	object	PodDisruptionBudget configuration per service. Ensures pod availability during voluntary disruptions like node drains and EKS node group upgrades. For single-replica deployments (effective replicas == 1), the PDB is not created even if minAvailable is 1, to avoid blocking node drains. For multi-replica deployments (effective replicas > 1), template rendering will fail if minAvailable is greater than or equal to the effective replica count, because such a PDB would prevent voluntary disruptions. The effective replica count used in these checks is the configured minimum replica count for each service (for example, clusterSize.minNumMySQLServers / clusterSize.minNumRdrs), not any dynamically autoscaled replica count at runtime.
podDisruptionBudget.mysqld	object
podDisruptionBudget.mysqld.enabled	boolean		True
podDisruptionBudget.mysqld.minAvailable	integer		1
podDisruptionBudget.ndbmtd	object
podDisruptionBudget.ndbmtd.enabled	boolean		True
podDisruptionBudget.ndbmtd.minAvailable	integer		1
podDisruptionBudget.rdrs	object
podDisruptionBudget.rdrs.enabled	boolean		True
podDisruptionBudget.rdrs.minAvailable	integer		1
priorityClass	string		rondb-high-priority
rdrs	object
rdrs.externalMetadataCluster	object	RDRSs will always be in the cluster of the data, not the metadata
rdrs.externalMetadataCluster.mgmds	array		[]
rdrs.externalMetadataCluster.slotsPerNode	integer		1
rdrs.featureStore	object	Feature store settings of every RDRS pod, rendered as the FeatureStore section of rest_api.json only when a key is set, so RDRS images that predate a key keep starting. When installed through the Hopsworks chart, the path is rondb.rondb.rdrs.featureStore.
rdrs.featureStore.metadataCachePreloadThreads	[‘integer’, ‘null’]	Threads that preload the feature view metadata cache from RonDB in parallel at startup (FeatureStore.FeatureStoreMetadataCache.PreloadThreads); the startup probe passes only once preloading is done. At least 1. RDRS default 3.
rdrs.hpa	object	Horizontal Pod Autoscaler for RDRS
rdrs.hpa.additionalMetrics	array	Additional metrics to use for the HPA. This is useful for custom metrics that are not supported by default.	[]
rdrs.internal	object	Request handling, scan diagnostics and memory settings of every RDRS pod, rendered as the Internal section of rest_api.json. Each key is rendered only when set, and the section only when at least one key is set, so RDRS images that predate a key keep starting (they reject unknown keys). DisableTransparentHugePages, MaxHttpReqSize, MaxBuffers, BufferPoolSharePercent, BufferShrinkAfterS, MaxBlobTextValueBytes, MaxOperationsPerBatchRequest and MaxOperationsPerNdbExecute need RDRS 26.02.12 or newer. When a key is null, RDRS uses its own default; for maxBuffers that default (0) derives the cap from the pod’s memory limit. The request and response buffer sizes are not settings: RDRS computes them from the RonDB row limits (ReqBufferSize and RespBufferSize were removed from RDRS in RONDB-1144). When installed through the Hopsworks chart, the path is rondb.rondb.rdrs.internal.
rdrs.internal.bufferPoolSharePercent	[‘integer’, ‘null’]	Share of the pod’s memory limit the buffer pools, together with the JSON responses written from them, may use when maxBuffers is derived. RDRS default 50; the rest is left for the JSON parse buffers, the NDB API and the process itself, so keep the memory limit at 2 GiB or more.
rdrs.internal.bufferShrinkAfterS	[‘integer’, ‘null’]	Seconds of idle time after which buffers above preAllocatedBuffers are unmapped and returned to the OS. 0 disables the shrink. Chart default 900 (15 minutes), so a pool that serves bursts some minutes apart keeps its buffers; this is the one Internal key the chart renders by default. null leaves the RDRS default, 300 (five minutes); RDRS images before 26.02.12 reject the key, so set it to null with them.	900
rdrs.internal.disableTransparentHugePages	[‘boolean’, ‘null’]	Internal.DisableTransparentHugePages. RDRS 26.02.12 and newer opts its process out of transparent huge pages at startup (prctl PR_SET_THP_DISABLE); false allows THP again. On nodes with transparent_hugepage/enabled=always, khugepaged collapses the sparse memory of an idle RDRS into resident 2 MiB pages until the pod reaches its memory limit and is restarted by its probes, with no traffic and nothing logged. Leave it null unless THP is wanted. Images before 26.02.12 do not opt out and reject the key: leave it null with them and set transparent_hugepage/enabled=madvise on the nodes. RDRS default true.
rdrs.internal.maxBlobTextValueBytes	[‘integer’, ‘null’]	Largest BLOB or TEXT value, in stored bytes, that a read returns (Internal.MaxBlobTextValueBytes). A read of a larger value fails with 413 naming the column; in a batch only that operation fails. 0 means no limit. RDRS default 2097152 (2 MiB).
rdrs.internal.maxBuffers	[‘integer’, ‘null’]	Cap on the buffers of each kind the pool may hold; a request that needs more is answered 503 “buffer pool exhausted”. 0 or null: derived from the pod’s memory limit and bufferPoolSharePercent. When non-zero, it must be at least 2 and at least preAllocatedBuffers (RDRS default 128); the chart fails the render otherwise, as rdrs2 would refuse to start.
rdrs.internal.maxHttpReqSize	[‘integer’, ‘null’]	Maximum HTTP body size of a REST request in bytes (Internal.MaxHttpReqSize; RDRS images before 26.02.12 call it maxReqSize); larger bodies are rejected before RDRS parses them. Every worker thread keeps a parse buffer of this size, so rest.numThreads times this value is part of the pod’s memory budget. At least 256. RDRS default 1048576 (1 MiB).
rdrs.internal.maxOperationsPerBatchRequest	[‘integer’, ‘null’]	Largest number of operations one batch request may carry (for a batch feature store request: entries); larger batches are answered 413 before any buffer is taken. Large batches of wide rows can take most of a 2 GiB pod’s buffer pool; raise the RDRS memory limit for such workloads. RDRS default 4096.
rdrs.internal.maxOperationsPerNdbExecute	[‘integer’, ‘null’]	Operations of a batch request RDRS sends to NDB in one execute round; not a cap on the batch request (see maxOperationsPerBatchRequest). Between 50 and 512. RDRS default 128. Replaces BatchMaxSize, which RDRS 26.02.12 and newer no longer reads.
rdrs.internal.operationIdMaxSize	[‘integer’, ‘null’]	Maximum length of an operation ID string in a batch request (Internal.OperationIDMaxSize). At most 4096. RDRS default 256.
rdrs.internal.preAllocatedBuffers	[‘integer’, ‘null’]	Request and response buffers of each kind mapped at startup and never released by the idle shrink. RDRS default 128.
rdrs.internal.scanRespBufferSize	[‘integer’, ‘null’]	Initial reservation for the JSON of a scan response, in bytes; the buffer grows when a response exceeds it. At least 1024. RDRS default 262144 (256 KiB).
rdrs.internal.scanTimingEnabled	[‘boolean’, ‘null’]	Collect scan timing metrics: a per-scan timing breakdown and a circular buffer of slow scans for diagnostics. RDRS default false.
rdrs.internal.slowScanBufferSize	[‘integer’, ‘null’]	Number of slow scan entries kept in the circular buffer (needs scanTimingEnabled). RDRS default 1000.
rdrs.internal.slowScanThresholdUs	[‘integer’, ‘null’]	Scans taking longer than this many microseconds are recorded in the slow scan buffer (needs scanTimingEnabled). RDRS default 10000 (10 ms).
rdrs.log	object	Logging of every RDRS pod, rendered as the Log section of rest_api.json. The pod logs to stdout, so the log file keys (FilePath, MaxSizeMb, MaxBackups, MaxAge) are not exposed. When installed through the Hopsworks chart, the path is rondb.rondb.rdrs.log.
rdrs.log.level	enum: [panic, fatal, error, warn, warning, info, debug, trace, null]	Log level (Log.Level), rendered only when set; null leaves RDRS at its own default, warn. Current rdrs2 releases parse the key but do not act on it (logging goes through the NDB event logger at a fixed level).
rdrs.maxKeepaliveRequests	integer	Maximum number of requests served on one keep-alive connection to the RDRS main port; after it the connection is closed gracefully (Connection: close). 0 (the default) disables the limit. A Kubernetes Service balances per TCP connection, so long-lived connections keep the skew that builds up after a rolling restart; bounding their lifetime lets clients re-balance. Each reconnect costs a TCP+TLS handshake: use a high value (1000 recommended, not below 500) and only where post-restart skew is observed. Does not apply to the probe port. Requires an RDRS image with REST.MaxKeepaliveRequests support (releases 26.02.11 and newer on the 26.02 line); at 0 the key is not emitted, so older images keep working.	0
rdrs.probePort	object	Dedicated RDRS probe listener. It serves only the ping and health endpoints, from its own thread, so Kubernetes probes keep being answered while every worker thread is blocked on data-node operations (a stalled data node otherwise fails the liveness probe of all RDRS pods at once). The probe port performs NO authentication, regardless of the PingRequiresAuth/HealthRequiresAuth settings. It is not published as a port of any Service or Ingress, but like any pod port it is reachable via pod IPs and the headless Service’s DNS records; where isolation is required, enforce it with a NetworkPolicy. Requires an RDRS image with REST.ProbePort support (releases 26.02.11 and newer on the 26.02 line): older images reject the unknown config keys at startup, so set enabled to false for pinned older images. Trade-off: the probe port answers as long as the process lives, so an RDRS whose worker threads are permanently wedged is not restarted by liveness.
rdrs.probePort.enabled	boolean	Serve ping/health on the dedicated probe port and point the startup, liveness and readiness probes at it (ping answers 503 until the main port accepts connections, so startup semantics are unchanged). false emits no probe configuration keys and points all probes back at the main port: the escape hatch for pinned RDRS images that predate REST.ProbePort.	True
rdrs.probePort.port	integer	TCP port of the dedicated probe listener. Must differ from the main REST port (4406).	4407
rdrs.probes	object	Timings of the RDRS container probes; the HTTP path, port and scheme are set by the chart. When installed through the Hopsworks chart, the path is rondb.rondb.rdrs.probes. A probe gives up after roughly (failureThreshold - 1) * periodSeconds + timeoutSeconds of consecutive failures.
rdrs.probes.liveness	object	Checks /ping and restarts RDRS when it keeps failing. With rdrs.probePort.enabled (the default) /ping is answered from the dedicated probe thread, which keeps responding through data-node failures, so the defaults are ample. With probePort.enabled=false /ping shares the worker threads: while a failed data node has not yet been declared dead, requests touching it block and /ping cannot answer. Detection takes ~25 seconds per data node, so in that mode size (failureThreshold - 1) * periodSeconds + timeoutSeconds above ~25 seconds per data node that can go silent at once, plus ~40 seconds. The defaults give ~115 seconds; restarting the data nodes of 8 node groups in parallel needs failureThreshold 30 (~295 seconds).
rdrs.probes.liveness.failureThreshold	integer		12
rdrs.probes.liveness.initialDelaySeconds	integer		5
rdrs.probes.liveness.periodSeconds	integer		10
rdrs.probes.liveness.timeoutSeconds	integer		5
rdrs.probes.readiness	object	Checks /health. A pod that keeps failing is removed from the Service after ~13 to 18 seconds with the defaults; connections it already holds stay open. More than one failure is required so that a single slow check under load does not take the pod out of the Service.
rdrs.probes.readiness.failureThreshold	integer		3
rdrs.probes.readiness.initialDelaySeconds	integer		5
rdrs.probes.readiness.periodSeconds	integer		5
rdrs.probes.readiness.timeoutSeconds	integer		3
rdrs.probes.startup	object	Checks /ping until RDRS first answers; liveness and readiness only start after it passes. RDRS opens its port once it has preloaded its caches from RonDB, about 25 seconds with a few hundred feature views. Raise failureThreshold if that preload takes longer than the ~57 seconds allowed.
rdrs.probes.startup.failureThreshold	integer		11
rdrs.probes.startup.initialDelaySeconds	integer		5
rdrs.probes.startup.periodSeconds	integer		5
rdrs.probes.startup.timeoutSeconds	integer		2
rdrs.rateLimit	object	USER rate limiting of the NDB traffic of every RDRS pod (RONDB-978), rendered as the RateLimit section of rest_api.json only when a key is set, so RDRS images that predate it keep starting. The identity is always the Hopsworks API key of the request: RateLimit.Identity has no other legal value and is not exposed. When installed through the Hopsworks chart, the path is rondb.rondb.rdrs.rateLimit.
rdrs.rateLimit.enable	[‘boolean’, ‘null’]	Tag the NDB transactions of REST requests with the request’s API key so the data nodes enforce USER rate limits. The data nodes must run with ActivateRateLimits, and an identity without a provisioned USER entity runs unmetered. RDRS default false.
rdrs.rateLimit.fullApiKey	[‘boolean’, ‘null’]	Use the full API key as the rate limit identity (RateLimit.FullAPIKey) instead of its prefix. RDRS default false.
rdrs.rest	object	HTTP server settings of every RDRS pod, rendered into the REST section of rest_api.json next to the chart-managed listener keys (ServerIP, ServerPort, ProbeEnable, ProbePort). Each key is rendered only when set, so RDRS images that predate a key keep starting (they reject unknown keys). rdrs.maxKeepaliveRequests and rdrs.uploadPath are the same kind of key and stay where they are. When installed through the Hopsworks chart, the path is rondb.rondb.rdrs.rest.
rdrs.rest.idleConnectionTimeoutS	[‘integer’, ‘null’]	Seconds a keep-alive connection on the main port may sit idle before RDRS closes it; 0 keeps the built-in 60 second timeout. Complements rdrs.maxKeepaliveRequests for clients that hold connections open but send rarely. Does not apply to the probe port. Requires an RDRS image with REST.IdleConnectionTimeoutS support (releases 26.02.11 and newer on the 26.02 line). RDRS default 0.
rdrs.rest.numThreads	[‘integer’, ‘null’]	Worker threads of the RDRS HTTP server (REST.NumThreads). Each thread holds a JSON parse buffer of internal.maxHttpReqSize bytes (1 MiB by default), so the thread count is part of the pod’s memory budget. Between 2 and 991. RDRS default 64.
rdrs.rest.useCompression	[‘boolean’, ‘null’]	Send responses gzip-compressed. RDRS default true.
rdrs.rest.useSingleTransaction	[‘boolean’, ‘null’]	Run all operations of a batch request in one NDB transaction. RDRS default true.
rdrs.rondb	object	Connection and retry settings of every RDRS pod towards RonDB. The chart renders each set key into BOTH the RonDB (data) and the RonDBMetadataCluster (metadata) sections of rest_api.json, which have the same keys; the management server addresses, connection pool sizes and node IDs of both sections come from rondbConfig and rdrs.externalMetadataCluster. Each key is rendered only when set. When installed through the Hopsworks chart, the path is rondb.rondb.rdrs.rondb.
rdrs.rondb.connectionRetries	[‘integer’, ‘null’]	Attempts to connect to the cluster before RDRS gives up. RDRS default 5.
rdrs.rondb.connectionRetryDelayInSec	[‘integer’, ‘null’]	Seconds to wait after a failed connection attempt before trying again. RDRS default 5.
rdrs.rondb.opRetryInitialDelayInMS	[‘integer’, ‘null’]	Delay in milliseconds before the first retry of an operation. RDRS default 500.
rdrs.rondb.opRetryJitterInMS	[‘integer’, ‘null’]	Random jitter in milliseconds added to each retry delay. RDRS default 100.
rdrs.rondb.opRetryOnTransientErrorsCount	[‘integer’, ‘null’]	Times an operation that failed with a transient NDB error is retried. RDRS default 3.
rdrs.security	object
rdrs.security.apiKey	object
rdrs.security.apiKey.cacheRefreshIntervalMS	integer	How often the API key cache refreshes project associations from the database (in milliseconds). Lower values reduce staleness when project memberships change but increase database load.	180000
rdrs.security.apiKey.preloadThreads	[‘integer’, ‘null’]	Threads that preload the API key cache from RonDB in parallel at startup (Security.APIKey.PreloadThreads); the startup probe passes only once preloading is done. At least 1. RDRS default 3. Rendered only when set, so RDRS images that predate the key keep starting.
rdrs.ttlPurge	object	TTL purge worker settings of every RDRS pod, rendered as the TTLPurge section of rest_api.json. The section is rendered only when at least one field is set, because RDRS older than RonDB 26.02.9 rejects the TTLPurge key and does not start. Changes reach running pods only when they restart; a cluster-wide window in the mysql.ttl_purge_ctrl table takes precedence over activeWindow and needs no restart. When installed through the Hopsworks chart, the path is rondb.rondb.rdrs.ttlPurge. Unknown fields fail the render, so a misspelled field cannot silently leave purging running around the clock.
rdrs.ttlPurge.activeWindow	[‘string’, ‘null’]	Daily UTC window during which the TTL purge worker deletes expired rows, formatted “HH:MM-HH:MM” (e.g. “03:00-05:00”); it wraps past midnight when start > end (e.g. “23:00-02:00”). Start and end must differ. When null or empty, purging runs around the clock. A valid window in mysql.ttl_purge_ctrl (ctrl_id 2/3) takes precedence.
rdrs.ttlPurge.enable	[‘boolean’, ‘null’]	Whether the RDRS pods run the TTL purge worker, which deletes expired rows of TTL tables. When null, RDRS decides (enabled). Can still be changed per pod at runtime through PUT /0.1.0/ttl-purge/config, until the pod restarts.
rdrs.uploadPath	string	Writable directory where RDRS buffers HTTP request bodies larger than 64KiB. The container’s working directory is not writable (RDRS runs as uid 1000): without this, every startup logs 256 ‘Permission denied’ errors and oversized bodies are silently read as empty. Requires an RDRS image with REST.UploadPath support (releases 26.02.11 and newer on the 26.02 line); set to the empty string for pinned older images, which reject the unknown key.	/tmp/rdrs-uploads
resources	object	Vertical cluster size
resources.limits	object	Kubernetes resource limits
resources.limits.cpus	object	CPU resources per RonDB service type
resources.limits.cpus.benchs	number		2
resources.limits.cpus.mgmds	number		0.2
resources.limits.cpus.mysqldExporters	number		0.2
resources.limits.cpus.mysqlds	number		2
resources.limits.cpus.ndbmtds	number		2
resources.limits.cpus.rdrs	number		2
resources.limits.cpus.restore	number		1
resources.limits.memory	object	Memory resources per RonDB service type
resources.limits.memory.benchsMiB	integer		500
resources.limits.memory.mysqldExportersMiB	integer		100
resources.limits.memory.mysqldMiB	integer	This can usually be kept at the default independent of the load	1400
resources.limits.memory.ndbmtdsMiB	integer	It is recommended to keep this above 5GiB, otherwise some memory parts will be configured manually.	5000
resources.limits.memory.rdrsMiB	integer		2048
resources.requests	object	Kubernetes resource requests; Note that data nodes will only apply limits, not requests
resources.requests.cpus	object	CPU resources per RonDB service type
resources.requests.cpus.benchs	number		1
resources.requests.cpus.mgmds	number		0.2
resources.requests.cpus.mysqldExporters	number		0.02
resources.requests.cpus.mysqlds	number		1
resources.requests.cpus.rdrs	number		1
resources.requests.memory	object	Memory resources per RonDB service type
resources.requests.memory.benchsMiB	integer		100
resources.requests.memory.mysqldExportersMiB	integer		50
resources.requests.memory.mysqldMiB	integer	This can usually be kept at the default independent of the load	650
resources.requests.memory.rdrsMiB	integer		2048
resources.requests.storage	object	Volume specifications
resources.requests.storage.binlogGiB	integer	Keep in mind that this size needs to survive the retention period of the binlog files	4
resources.requests.storage.classes	object	Storage classes
resources.requests.storage.classes.binlogFiles	[‘string’, ‘null’]	Storage class name for MySQLd binlog volumes in global replication
resources.requests.storage.classes.default	[‘string’, ‘null’]	Default storage class name for all volumes
resources.requests.storage.classes.diskColumns	[‘string’, ‘null’]	Storage class name for the data node disk columns volume
resources.requests.storage.classes.mgmd	[‘string’, ‘null’]	Storage class name for Management server
resources.requests.storage.diskColumnGiB	integer	This depends on how much data the user is expecting to place on disk	2
resources.requests.storage.logGiB	integer		2
resources.requests.storage.mgmdGiB	integer	The size of the statefulSet persistent volume for the RonDB management node. It will be used in new installations or in case of lookup function failing during upgrade in argo deployments.	1
resources.requests.storage.ndbmtdGiB	integer	The size of the statefulSet persistent volume for the RonDB data nodes. It will be used in new installations or in case of lookup function failing during upgrade in argo deployments.	30
resources.requests.storage.redoLogGiB	integer	64GiB is recommended for optimal performance	4
resources.requests.storage.relayLogGiB	integer		2
resources.requests.storage.undoLogsGiB	integer	64GiB is recommended for good performance	4
restoreFromBackup	object	Whether to restore a backup on the cluster
restoreFromBackup.backupId	[‘string’, ‘null’]	The native backup ID for the backup to restore
restoreFromBackup.excludeDatabases	array	Which databases to exclude from the native backup	[]
restoreFromBackup.excludeTables	array	Which tables to exclude from the native backup. Use the format: database.table	[]
restoreFromBackup.forceDataClear	[‘boolean’, ‘null’]	Confirm that existing data will be destroyed during in-place restore.
restoreFromBackup.inPlace	[‘boolean’, ‘null’]	Enable in-place restore on existing cluster. Requires forceDataClear=true.
restoreFromBackup.objectStorageProvider	enum: [s3]		s3
restoreFromBackup.pathPrefix	string	Prefix of RonDB backup in the configured bucket	rondb_backup
restoreFromBackup.s3	object
restoreFromBackup.s3.bucketName	[‘string’, ‘null’]
restoreFromBackup.s3.endpoint	[‘string’, ‘null’]
restoreFromBackup.s3.keyCredentialsSecret	object
restoreFromBackup.s3.keyCredentialsSecret.key	[‘string’, ‘null’]	Key in the Secret
restoreFromBackup.s3.keyCredentialsSecret.name	[‘string’, ‘null’]	Name of the Secret
restoreFromBackup.s3.provider	[‘string’, ‘null’]
restoreFromBackup.s3.region	[‘string’, ‘null’]
restoreFromBackup.s3.secretCredentialsSecret	object
restoreFromBackup.s3.secretCredentialsSecret.key	[‘string’, ‘null’]	Key in the Secret
restoreFromBackup.s3.secretCredentialsSecret.name	[‘string’, ‘null’]	Name of the Secret
restoreFromBackup.s3.serverSideEncryption	enum: [aws:kms, aws:kms:dsse, AES256, null]
rondbConfig	object	Configurations for RonDB’s config.ini. Memory configurations are in binary SI units (i.e. 1G = 1GiB = 1024MiB).
rondbConfig.ActivateRateLimits	integer	Activate rate limits handling	0
rondbConfig.BackupLogBufferSize	string	Buffer that records writes occurring during an online backup; the backup aborts if it fills. Default 16M; increase (e.g. 256M) for write-heavy clusters. See https://docs.rondb.com/rondb_backup/.	16M
rondbConfig.DataMemory	[‘string’, ‘null’]	Memory available for storing in-memory database records on each data node, in bytes (with optional binary SI suffix, e.g. ‘4G’). When unset, RonDB’s AutomaticMemoryConfig sizes this from the container’s memory; only set explicitly to override automatic sizing. Only applied if explicitly set.
rondbConfig.DiskPageBufferMemory	[‘string’, ‘null’]	DiskPageBufferMemory are used by disk columns. This is the page cache that contains disk pages when they are in memory. By default it is not defined.
rondbConfig.EmptyApiSlots	integer	We need at least 1 for the MySQLd setup job. Otherwise this is for services that are not handled here, e.g. HopsFS	8
rondbConfig.FullRestartLogs	[‘boolean’, ‘null’]	Enable full restart logs (RonDB-specific). RonDB’s release-build default is false.
rondbConfig.HeartbeatIntervalDbApi	integer	Each data node sends heartbeat signals to each MySQL server (SQL node) to ensure that it remains in contact. If a MySQL server fails to send a heartbeat in time it is declared “dead,” in which case all ongoing transactions are completed and all resources released. The SQL node cannot reconnect until all activities initiated by the previous MySQL instance have been completed. The three-heartbeat criteria for this determination are the same as described for HeartbeatIntervalDbDb.	5000
rondbConfig.HeartbeatIntervalDbDb	integer	One of the primary methods of discovering failed nodes is by the use of heartbeats. This parameter states how often heartbeat signals are sent and how often to expect to receive them. Heartbeats cannot be disabled. After missing four heartbeat intervals in a row, the node is declared dead. Thus, the maximum time for discovering a failure through the heartbeat mechanism is five times the heartbeat interval.	5000
rondbConfig.InitialTablespaceSizeGiB	integer	InitialTableSpace size in GiB. By default, it is set to -1, which enforces the initial tablespace to use the entire diskColumnGiB space. If set to 0, the same behaviour applies and the diskColumnGiB is used.	-1
rondbConfig.LongMessageBuffer	[‘string’, ‘null’]	Internal buffer used for passing long messages within and between nodes, in bytes (with optional binary SI suffix). NDB’s built-in default is 64M. Only applied if explicitly set.
rondbConfig.MaxDMLOperationsPerTransaction	integer		32768
rondbConfig.MaxDiskWriteSpeed	[‘string’, ‘null’]	Maximum disk write speed (bytes/sec, total across all ldm threads) used by local checkpoints during normal operation, i.e. when no node is restarting. The adaptive algorithm may write more slowly than this ceiling based on CPU usage and REDO log IO lag, but will not exceed it. Only applied if explicitly set; otherwise RonDB’s built-in default is used. See https://docs.rondb.com/rondb_advanced_fs_config/.
rondbConfig.MaxNoOfAttributes	[‘integer’, ‘null’]
rondbConfig.MaxNoOfConcurrentOperations	integer		65536
rondbConfig.MaxNoOfSchemaObjects	[‘integer’, ‘null’]	Maximum total number of schema objects (tables, ordered indexes, unique hash indexes, etc.) that a data node may allocate. Increase this when the application needs more than the default cap of 20,320 table objects. Only applied if explicitly set; otherwise RonDB’s built-in default is used. See https://docs.rondb.com/automatic_memory_config/.
rondbConfig.MaxNoOfTables	[‘integer’, ‘null’]
rondbConfig.MaxNoOfTriggers	[‘integer’, ‘null’]
rondbConfig.MaxRRGroupSize	[‘integer’, ‘null’]	Max size of a Round Robin (RR) group. RonDB default is 8; allowed range is 8 to 32.
rondbConfig.MySQLdSlotsPerNode	integer		4
rondbConfig.OsCpuOverhead	[‘string’, ‘null’]	Additional OS memory overhead for the RonDB datanode containers. This is multiplied by the number of CPUs. Also only set this if the container has less than 5GiB of memory.
rondbConfig.OsStaticOverhead	[‘string’, ‘null’]	Memory overhead for the RonDB datanode containers. Only set this if the container has less than 5GiB of memory.
rondbConfig.PartitionsPerNode	[‘integer’, ‘null’]	Number of partitions per data node used when creating new tables. When null, RonDB chooses based on AutomaticThreadConfig / NumCPUs (typically the number of LDM threads). Only affects tables created after the change; existing tables are not repartitioned.
rondbConfig.RdrsMetadataSlotsPerNode	integer	We use additional cluster connections for metadata	1
rondbConfig.RdrsSlotsPerNode	integer	The number of cluster connections we support via the RDRS	1
rondbConfig.RedoBuffer	[‘string’, ‘null’]
rondbConfig.ReplicationMemory	[‘string’, ‘null’]
rondbConfig.ReservedConcurrentOperations	[‘integer’, ‘null’]
rondbConfig.SchemaMemory	[‘string’, ‘null’]
rondbConfig.SharedGlobalMemory	[‘string’, ‘null’]
rondbConfig.TimeBetweenGlobalCheckpoints	[‘integer’, ‘null’]	Time in milliseconds between group commits of transactions to disk. RonDB’s built-in default is 2000 ms. Only applied if explicitly set.
rondbConfig.TotalMemoryConfig	[‘string’, ‘null’]	The total memory configured by RonDB datanode. By default it is not defined and memory is calculated automatically.
rondbConfig.TransactionDeadlockDetectionTimeout	integer	Time transaction can spend executing within data node	1500
rondbConfig.TransactionInactiveTimeout	integer	Milliseconds that application waits before executing another part of transaction	15000
rondbConfig.TransactionMemory	[‘string’, ‘null’]
rondbConfig.UseOnlyIPv4	[‘boolean’, ‘null’]	When true, restricts all RonDB cluster connections to IPv4 sockets only. Applied under both [NDBD DEFAULT] and [MYSQLD DEFAULT] so it covers data nodes, MySQLds (including binlog/replica appliers/DDL), RDRS, and other API clients. Introduced in RonDB 21.04.5 for Dolphin SuperSockets compatibility.
rondbConfig.UseTcInRRGroup	[‘boolean’, ‘null’]	When true, each recv thread distributes connections only to TC threads within the same Round Robin (RR) group; when false, it distributes them across all TC threads. RonDB default is true.
serviceAccountAnnotations	object		{}
skipMgmdPreUpgradeRollout	boolean	If true, skip the pre-upgrade hook that rolls MGMd to the target image and config before the rest of the chart upgrades. The hook exists to keep at least one ArbitrationRank=1 node reachable while the API tier (mysqld, rdrs) is also rolling, preventing data-node arbitration loss (NDB Error 2305) on chart-wide upgrades. Set this to true only as an escape hatch if the hook itself is misbehaving on your cluster.	False
staticCpuManagerPolicy	boolean	Whether the Kubernetes cluster has been configured with a static CPU manager policy. This is an optimization for RonDB data nodes. These have a scheduler which executes jobs within hundreds of microseconds (very quick). If the data nodes are pinned to CPUs, they can run CPU spnning to avoid context switching inbetween jobs.	False
terminationGracePeriodSeconds	[‘object’, ‘integer’]	Pod terminationGracePeriodSeconds per RonDB service type. The chart’s daemons stop on SIGTERM, so this is a ceiling, not a wait: a pod is removed as soon as its processes have exited. The legacy integer form (charts up to 26.2.19) still validates (minimum 10) and keeps its meaning: it overrides the data nodes only, every other component keeps 30. Helm drops null keys before schema validation: a null whole key falls back to the defaults, a null component key is rejected (all six keys are required; partial values files still work because Helm merges in the chart defaults).
terminationGracePeriodSeconds.binlogServers	integer	Binlog server MySQLds; see mysqlds.	30
terminationGracePeriodSeconds.mgmds	integer	MGMd stops within seconds; this matches the Kubernetes default.	30
terminationGracePeriodSeconds.mysqlds	integer	Used by MySQLds and DDL MySQLds; mysqld stops within seconds under no load, but allow time for open transactions to close.	30
terminationGracePeriodSeconds.ndbmtds	integer	Data nodes run a managed stop on SIGTERM: deactivate through the MGMd, then node shutdown with handover. Large nodes additionally need roughly 2 minutes per TB of data node memory for the kernel to tear the process down, so raise this for nodes above 1TB. Stops of several data nodes serialize at the MGMd. When deleting the entire cluster the MGMd may already be gone; data nodes then retry the deactivate for up to 60s before stopping directly.	300
terminationGracePeriodSeconds.rdrs	integer	RDRS stops within a few seconds; this matches the Kubernetes default.	30
terminationGracePeriodSeconds.replicaAppliers	integer	Replica applier pods: the controller container stops its run_applier.sh worker on SIGTERM, the pod’s mysqld receives SIGTERM directly.	30
timeoutsMinutes	object	Using minutes for easier template addition
timeoutsMinutes.mysqldStartupProbe	integer	Maximum time a MySQLd pod (mysqld, ddl mysqld, binlog server, replica applier) is given to start up before Kubernetes restarts its container.	20
timeoutsMinutes.ndbmtdStartupProbe	integer	Maximum time a ndbmtd pod is given to start up before Kubernetes restarts its container. Node restarts with a lot of data to restore can take long. Must clear the worst-case data reload of the largest supported cluster - a node killed mid-recovery restarts from scratch and loops forever.	240
timeoutsMinutes.restoreNativeBackup	integer	This does not include downloading the native backups. IMPORTANT; Restoring native backups is NOT done in parallel yet; TODO: Make this dependent on amount of data	120
timeoutsMinutes.singleSetupMySQLds	integer	This includes the time to start a single MySQLd pod, restoring MySQL metadata and running user-defined MySQL init scripts.	5
tls	object	General settings how to use encrypted TLS connections with RonDB APIs (MySQL & RDRS).
tls.caSecretName	[‘string’, ‘null’]	User-provided TLS Secret. This can be used by the cert-manager as a base to sign further certificates. If not supplied, cert-manager will use a self-signed CA certificate.
tolerations	object	These tolerations allow Kubernetes to schedule pods on nodes with matching taints, ensuring proper placement based on cluster policies.
tolerations.backup	array		[]
tolerations.mgmd	array		[]
tolerations.mysqld	array		[]
tolerations.ndbmtd	array		[]
tolerations.rdrs	array		[]

This site is open source. Improve this page.