Installation Guide

Install accelerator support

helm repo add nvidia https://helm.ngc.nvidia.com/nvidia
helm repo update
helm install gpu-operator nvidia/gpu-operator \
  --namespace gpu-operator \
  --create-namespace
  # Add a trailing \ above before uncommenting the following setting.
  # --set driver.enabled=false

kubectl get pods --namespace gpu-operator

Install the Dynamo Platform

Set your environment variables:

export NAMESPACE=dynamo-system
export RELEASE_VERSION=1.2.1  # match a version from https://github.com/ai-dynamo/dynamo/releases

helm fetch https://helm.ngc.nvidia.com/nvidia/ai-dynamo/charts/dynamo-platform-$RELEASE_VERSION.tgz
helm install dynamo-platform dynamo-platform-$RELEASE_VERSION.tgz \
  --namespace $NAMESPACE \
  --create-namespace
  # Note: add \ to --create-namespace above when uncommenting any optional flags below
  #
  # Grove + KAI Scheduler — uncomment if using multinode or disaggregated inference.
  # Option A (install=true): Dynamo installs and manages Grove/KAI as bundled subcharts (dev/testing):
  # --set "global.grove.install=true" \
  # --set "global.kai-scheduler.install=true" \
  # --set-string "kai-scheduler.scheduler.args.default-staleness-grace-period=-1s" \
  # Option B (enabled=true): Grove/KAI are already installed externally (production):
  # --set "global.grove.enabled=true" \
  # --set "global.kai-scheduler.enabled=true" \
  #
  # kube-prometheus-stack — uncomment if Prometheus is installed (required for Planner sla mode and autoscaling):
  # --set "dynamo-operator.dynamo.metrics.prometheusEndpoint=http://prometheus-kube-prometheus-prometheus.monitoring.svc.cluster.local:9090"

kubectl get clusterrolebinding -o json | \
  jq -r '.items[] | select(.metadata.name | contains("dynamo-operator-manager")) |
  "Cluster-wide operator found in namespace: \(.subjects[0].namespace)"'

Verify the Dynamo platform is running:

# Check CRDs
kubectl get crd | grep dynamo
# Expected: dynamographdeployments, dynamocomponentdeployments, dynamographdeploymentrequests, etc.
# Check operator and platform pods
kubectl get pods -n $NAMESPACE
# Expected: dynamo-operator-* and nats-* pods all Running

Install Optional Components

The Dynamo install command above includes commented flags for each optional component. Install the component first, then uncomment the corresponding flag before running helm install in Step 2 (or run helm upgrade --reuse-values with the flag if you’ve already installed Dynamo).

Multinode:

Multinode deployments require an orchestrator for workloads that span multiple nodes. Gang scheduling is strongly recommended to schedule all required Pods together and avoid partial resource allocation that can leave workloads stalled. See Multinode Orchestration for details on orchestrator selection and configuration.

DisaggregatedSet is an opt-in multinode pathway below Grove. To request it for a new DGD, install an LWS release that serves disaggregatedset.x-k8s.io/v1 and set nvidia.com/enable-disaggregatedset: "true". When Grove is available and enabled, also set nvidia.com/enable-grove: "false". Dynamo persists the selected provider in nvidia.com/workload-provider; installing the DS API or changing the enable annotations does not change existing deployments. If the selected provider becomes unavailable, Dynamo reports Ready=False instead of silently switching providers. Delete and recreate the DGD to choose a different pathway.

The following sections describe how to enable gang scheduling for each supported orchestrator.

Grove + KAI Scheduler

There are two ways to enable Grove and KAI Scheduler, controlled by which flags you uncomment in the Dynamo install command:

• install=true — Dynamo installs and manages Grove/KAI as bundled subcharts. Simplest path; recommended for dev/testing.
• enabled=true — Tells Dynamo that Grove/KAI are already installed and externally managed. Use this when you install Grove/KAI separately (e.g., to manage their lifecycle independently or share them across namespaces). Recommended for production.

For the enabled=true path, install Grove and KAI Scheduler separately first. See the Grove installation guide and KAI Scheduler deployment guide for instructions.

LWS + Volcano

If you are not using Grove for multinode, you can use LeaderWorkerSet (LWS) (>= v0.7.0) with Volcano for gang scheduling. Both must be installed before deploying multinode workloads.

1. Install Volcano:

helm repo add volcano-sh https://volcano-sh.github.io/helm-charts
helm repo update
helm install volcano volcano-sh/volcano -n volcano-system --create-namespace

2. Install LWS with Volcano gang scheduling enabled. Use an LWS release that serves disaggregatedset.x-k8s.io/v1 (the current Dynamo operator dependency is LWS v0.10.0) when enabling DS; the standard DCD pathway supports LWS v0.7.0 or newer:

export LWS_VERSION=0.10.0
helm install lws oci://registry.k8s.io/lws/charts/lws \
  --version=$LWS_VERSION \
  --namespace lws-system \
  --create-namespace \
  --set gangSchedulingManagement.schedulerProvider=volcano \
  --wait --timeout 300s

See the LWS docs and Volcano docs for configuration options. See Multinode Orchestration to compare the supported orchestrators.

Network Operator / RDMA

RDMA setup is cloud-provider-specific. See RDMA Setup for requirements and platform-specific instructions:

• AKS — InfiniBand + Network Operator
• EKS — EFA device plugin (also see EFA on AWS)
• GKE — GPUDirect-TCPXO

kube-prometheus-stack

Install Prometheus before running the Dynamo install command so you can set the endpoint in one pass:

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update
helm install prometheus prometheus-community/kube-prometheus-stack \
  --namespace monitoring --create-namespace \
  --set prometheus.prometheusSpec.podMonitorSelectorNilUsesHelmValues=false \
  --set-json 'prometheus.prometheusSpec.podMonitorNamespaceSelector={}' \
  --set-json 'prometheus.prometheusSpec.probeNamespaceSelector={}'

Then uncomment the prometheusEndpoint line in the Dynamo install command. The Dynamo operator automatically creates PodMonitors for its components. See Metrics for dashboard setup and available metrics, and Logging for the Grafana Loki + Alloy logging stack.

Shared Storage for Model Caching

Set up a ReadWriteMany PVC so all pods share downloaded model weights instead of each downloading independently. No Dynamo chart flags are needed — storage is configured in your deployment spec. Setup is cloud-provider-specific:

• AKS — Azure Files / Managed Lustre
• EKS — EFS
• GKE — Cloud Filestore (see GKE guide)

For large clusters with frequent model updates, consider ModelExpress for P2P model distribution and ModelStreamer for direct streaming from object storage. See Model Caching for the full walkthrough including the download Job, mount configuration, and ModelExpress setup.

Pre-Deployment Check

Run the pre-deployment check script to validate your cluster is ready for deployments:

./deploy/pre-deployment/pre-deployment-check.sh

This checks kubectl connectivity, default StorageClass configuration, GPU node availability, and GPU Operator status. See Pre-Deployment Checks for details.