{"slug": "open-sourced-helm-chart-for-run-ai", "title": "Open-sourced helm chart for run:AI", "summary": "An open-source Helm chart has been published that installs NVIDIA Run:ai's control plane and cluster alongside the KAI Scheduler it schedules with, wrapping the upstream charts at version 3.0.20 from the helm.ngc.nvidia.com/nvidia/runai-oss repository. The chart adds release profiles, validation, the Secrets the upstream charts expect, and a cluster registration step, and must be installed once per namespace across three ordered releases: runai-prerequisites, runai-backend, and runai-cluster. It requires Kubernetes 1.30 or later, Helm 3.x or 4.x, kubectl, curl, jq, an ingress controller, a DNS name for global.domain, a TLS certificate, and a default StorageClass for the PostgreSQL, Thanos (100Gi) and NATS volumes.", "body_md": "Installs NVIDIA Run:ai (control plane and cluster) and the KAI Scheduler it schedules with\n\nThe chart wraps the published upstream charts and adds the glue between them: release profiles, validation, the Secrets the upstream charts expect to exist, and the cluster registration step.\n\n| Subchart | Upstream chart | Version | Repository | \n|---|---|---|---|\n| `controlplane` | `control-plane` | 3.0.20 | `https://helm.ngc.nvidia.com/nvidia/runai-oss` | \n| `cluster` | `runai-cluster` (bundles`kai-resource-management` v0.18.3 and`kai-scheduler` v0.18.3) | 3.0.20 | `https://helm.ngc.nvidia.com/nvidia/runai-oss` | \n| `kai` | `kai-scheduler` | v0.18.3 | `oci://ghcr.io/kai-scheduler/kai-scheduler` | \n| `monitoring` | `kube-prometheus-stack` | 76.2.0 | `https://prometheus-community.github.io/helm-charts` | \n| `gpu` | `gpu-operator` ,`fake-gpu-operator` | v26.7.1, 0.0.62 | `https://helm.ngc.nvidia.com/nvidia` ,`oci://ghcr.io/run-ai/fake-gpu-operator` | \n| `runailib` | library chart with the shared helpers |  |  | \n\nThe chart is installed once per namespace. Each release enables its components with a profile file:\n\n| Order | Release | Namespace | Profile | Installs | \n|---|---|---|---|---|\n| 1 | `runai-prerequisites` | any ( `runai-prerequisites` ) | `values.prerequisites.yaml` | Prometheus Operator, NVIDIA GPU Operator (or the fake GPU operator with `values.dev.yaml` ) | \n| 2 | `runai-backend` | `runai-backend` | `values.control-plane.yaml` | Run:ai control plane: backend services, UI, Keycloak, PostgreSQL, Thanos, NATS | \n| 3 | `runai-cluster` | `runai` | `values.cluster.yaml` | Run:ai cluster: operator, admission, agent, KAI Scheduler | \n|  | `kai-scheduler` | `kai-scheduler` | `values.kai-scheduler.yaml` | KAI Scheduler alone, for clusters without Run:ai | \n\nThe control plane and the cluster cannot share a release. The cluster's pre-install hooks call\nthe control-plane API with a cluster UUID and a bootstrap token, and the control plane issues\nboth only once it is running. `scripts/register_cluster.sh` registers the cluster and writes them\nto a values file for release 3.\n\nKAI Scheduler comes with release 3: `runai-cluster` depends on `kai-resource-management`, which\ndepends on `kai-scheduler`. The Run:ai operator writes KAI's `Config` and the\n`kai-resource-management` node-pool controller writes one `SchedulingShard` per node pool. The\nstandalone `kai-scheduler` profile is for clusters that run KAI without Run:ai,\nand the chart refuses to render it together with the cluster profile.\n\n- Kubernetes >= 1.30, Helm 3.x or 4.x, `kubectl` ,`curl` ,`jq` .\n- An ingress controller. The control plane creates an `Ingress` with class`nginx` by default\n(`global.ingress.ingressClass` ,`nginx` or`haproxy` ). OpenShift uses Routes.\n- A DNS name for the control plane (`global.domain` ) that resolves to the ingress controller, both\nfrom where`scripts/install.sh` runs and from inside the cluster.\n- A TLS certificate for `global.domain` : PEM in`controlplane.tls` , a cert-manager issuer in`controlplane.tls.certManager` , or a`kubernetes.io/tls` Secret`runai-backend-tls` created in\nnamespace`runai-backend` before the install.\n- A default StorageClass for the PostgreSQL, Thanos (100Gi) and NATS volumes.\n- A Prometheus Operator and an NVIDIA GPU stack (DCGM exporter). Release 1 installs both; skip it\nwith `--skip-prerequisites` when the cluster already has them.\n\nFrom a git checkout:\n\n```\n./helm_dependencies.sh\nscripts/install.sh --domain runai.example.com -f my-values.yaml\n```\n\n`my-values.yaml` is passed to every release. A minimal one with a certificate for the domain:\n\n```\ncontrolplane:\n  tls:\n    certificate: |\n      -----BEGIN CERTIFICATE-----\n      ...\n    key: |\n      -----BEGIN PRIVATE KEY-----\n      ...\n```\n\nWhen the certificate is signed by a private CA, also set the CA so the cluster components trust it:\n\n```\nglobal:\n  customCA:\n    enabled: true\n  _runai:\n    customCA:\n      certificate: |\n        -----BEGIN CERTIFICATE-----\n        ...\n```\n\nand pass `--cacert ca.pem` to `scripts/install.sh` for the registration calls.\n\n`scripts/install.sh --help` lists the options: `--skip-prerequisites`, `--skip-control-plane`,\n`--skip-cluster`, `--dev` (fake GPUs), `--cluster-name`, `--admin-user`, `--cacert`,\n`--insecure`, `--timeout`.\n\nThe UI is at `https://<global.domain>`. The admin user is `test@run.ai`\n(`controlplane.control-plane.tenantsManager.config.adminUsername`) and its password is generated:\n\n```\nkubectl get secret runai-backend-gen-tenants-manager -n runai-backend \\\n  -o jsonpath='{.data.ADMIN_PASSWORD}' | base64 -d\nhelm upgrade --install runai-prerequisites . -n runai-prerequisites --create-namespace \\\n  -f values.prerequisites.yaml --wait\n\nhelm upgrade --install runai-backend . -n runai-backend --create-namespace \\\n  -f values.control-plane.yaml -f my-values.yaml --set global.domain=runai.example.com \\\n  --wait --wait-for-jobs --timeout 20m\n\nscripts/register_cluster.sh --domain runai.example.com --output cluster-registration.yaml\n\nhelm upgrade --install runai-cluster . -n runai --create-namespace \\\n  -f values.cluster.yaml -f my-values.yaml -f cluster-registration.yaml \\\n  --wait --wait-for-jobs --timeout 20m\n```\n\n`cluster-registration.yaml` holds a bootstrap token. The control plane mints a new one on every\ncall, so regenerate the file before each install or upgrade of `runai-cluster`.\n\n```\nscripts/install.sh --domain runai.example.com --dev -f my-values.yaml\nkubectl label node <node> run.ai/simulated-gpu-node-pool=default\n```\n\n`values.dev.yaml` replaces the NVIDIA GPU Operator with the fake GPU operator, which reports\n8 Tesla-A10 GPUs on each labelled node.\n\n```\nhelm upgrade --install kai-scheduler . -n kai-scheduler --create-namespace \\\n  -f values.kai-scheduler.yaml --wait\n```\n\nKAI creates the queues `default-parent-queue` and `default-queue` on first install. Pods opt in\nwith `schedulerName: kai-scheduler` and the label `kai.scheduler/queue: default-queue`.\n\nLayer `values.openshift.yaml` on every release. Upstream detects OpenShift with `lookup`, which\nreturns nothing under `helm template`, so the file states it: it sets\n`global.config.kubernetesDistribution: openshift` (Routes and SCCs in the control plane) and\nforces OpenShift mode in `runai-cluster`, `kai-resource-management` and `kai-scheduler`. Leave\n`global._runai.monitoring` off: the Run:ai operator uses `openshift-monitoring`.\n\nArgoCD renders with `helm template`, so:\n\n- Set `global._runai.mode: install` (or`upgrade` ):`lookup` returns nothing, and the chart then\nrenders the`runai-reservation` Namespace unconditionally.\n- Create one Application per release, synced in the order of the table above.\n- The cluster Application needs the registration values. Run `scripts/register_cluster.sh` and\nstore its output in a Secret-backed values source, since it holds a bootstrap token.\n\nThe Run:ai cluster takes its routing settings through `clusterConfig`, a merge patch into its\n`RunaiConfig`. To use HAProxy instead of nginx:\n\n```\ncluster:\n  runai-cluster:\n    clusterConfig:\n      global:\n        ingress:\n          ingressClass: haproxy\n```\n\nNVIDIA also publishes the commercial Run:ai line (2.x) as `control-plane` and `runai-cluster` in\n`https://helm.ngc.nvidia.com/nvidia/runai`, which needs an NGC API key. Those charts take the\nsame install values (`controlPlane.url`, `controlPlane.clientSecret`, `cluster.uid`,\n`cluster.url`, `clusterConfig`). Their `runai-cluster` 2.26.50 schedules with the proprietary\n`runai-engine` (v3.41.19, from `nvcr.io/artifactory`) instead of KAI Scheduler. This chart wraps the\nopen-source 3.x line from `nvidia/runai-oss`.\n\nEach subchart passes its upstream chart's values one level down, for example\n`controlplane.control-plane.keycloakx`, `cluster.runai-cluster.kai-resource-management` or\n`monitoring.kube-prometheus-stack.grafana`. The upstream charts also read these globals:\n\n| Key | Read by | Purpose | \n|---|---|---|\n| `global.domain` | control plane | FQDN of the control plane | \n| `global.ingress.ingressClass` | control plane | `nginx` (default) or`haproxy` | \n| `global.config.kubernetesDistribution` | control plane | `kubernetes` or`openshift` | \n| `global.image.registry` | control plane, cluster | Registry for Run:ai images (default `nvcr.io/nvidia/runai-oss` ) | \n| `global.customCA.enabled` | control plane, cluster | Trust the CA in Secret `runai-ca-cert` | \n| `global.imagePullSecrets` | control plane, KAI | Pull secrets as `[{name: ...}]` | \n| `global.additionalImagePullSecrets` | cluster | Pull secrets as a list of names | \n\n| Key | Type | Default | Description | \n|---|---|---|---|\n| cluster | object | `{}` | Cluster subchart: the upstream values under cluster.runai-cluster, including the registration values and KAI under cluster.runai-cluster.kai-resource-management.kai-scheduler. See charts/cluster/values.yaml. | \n| controlplane | object | `{}` | Control-plane subchart: TLS for global.domain, and the upstream values under controlplane.control-plane. See charts/controlplane/values.yaml. | \n| global._runai.cluster.enabled | bool | `false` | Run:ai cluster, including KAI Scheduler. Release namespace must be runai. Needs a running control plane and the values scripts/register_cluster.sh writes. | \n| global._runai.controlPlane.enabled | bool | `false` | Run:ai control plane. Release namespace must be runai-backend. | \n| global._runai.customCA.certificate | string | `\"\"` | PEM CA bundle rendered into the runai-ca-cert Secret of the release namespace when global.customCA.enabled is true. Leave empty to create runai-ca-cert yourself. | \n| global._runai.gpu.enabled | bool | `false` | NVIDIA GPU Operator, or the fake GPU operator (gpu.fake-gpu-operator.enabled). | \n| global._runai.kaiScheduler.enabled | bool | `false` | Standalone KAI Scheduler, without Run:ai. Upstream documents namespace kai-scheduler. Never together with cluster, which bundles KAI. | \n| global._runai.mode | string | `\"auto\"` | \"auto\" lets templates call lookup. Set \"install\" or \"upgrade\" when rendering with `helm template` (ArgoCD), where lookup returns nothing. | \n| global._runai.monitoring.enabled | bool | `false` | kube-prometheus-stack. The Run:ai cluster requires a Prometheus Operator. | \n| global._runai.registry.password | string | `\"\"` | Registry password or token. | \n| global._runai.registry.server | string | `\"\"` | Registry host for the control-plane pull secret runai-reg-creds. Nothing is rendered unless server, username and password are all set. The images on nvcr.io/nvidia/runai-oss are public. | \n| global._runai.registry.username | string | `\"\"` | Registry user. | \n| global.customCA.enabled | bool | `false` | Trust the CA in Secret runai-ca-cert (key runai-ca.pem). Needed when the control-plane certificate is not signed by a public CA. | \n| global.domain | string | `\"\"` | FQDN the control plane is served on. Required by the controlPlane component. | \n| global.imagePullSecrets | list | `[]` | Pull secrets for control-plane and KAI pods, as [{name: }]. The Run:ai cluster reads global.additionalImagePullSecrets (a list of names) instead. | \n| gpu | object | `{}` | GPU subchart: gpu.gpu-operator and gpu.fake-gpu-operator, each with an enabled switch. | \n| kai | object | `{}` | Standalone KAI subchart: the upstream values under kai.kai-scheduler. | \n| monitoring | object | `{}` | Monitoring subchart: the upstream values under monitoring.kube-prometheus-stack. |", "url": "https://wpnews.pro/news/open-sourced-helm-chart-for-run-ai", "canonical_source": "https://github.com/logicalclocks/run-ai-helm", "published_at": "2026-10-15 12:11:30+00:00", "updated_at": "2026-10-15 12:20:39.439431+00:00", "lang": "en", "topics": ["ai-infrastructure", "mlops", "ai-tools", "developer-tools"], "entities": ["NVIDIA", "Run:ai", "KAI Scheduler", "Kubernetes", "Helm", "Prometheus Operator", "NVIDIA GPU Operator", "Keycloak"], "also_reported_by": [], "alternates": {"html": "https://wpnews.pro/news/open-sourced-helm-chart-for-run-ai", "markdown": "https://wpnews.pro/news/open-sourced-helm-chart-for-run-ai.md", "text": "https://wpnews.pro/news/open-sourced-helm-chart-for-run-ai.txt", "jsonld": "https://wpnews.pro/news/open-sourced-helm-chart-for-run-ai.jsonld"}}