Skip to content

Build1 publisher3 min readPublished

NVIDIA's NVCRE runs the NCCL test that Slurm gets from a single srun command

NVIDIA's open source Cluster Readiness Engine runs real distributed workloads on named node groups and reports which nodes failed. The published sample takes 42 minutes to fail an eight-node all-reduce.

The Engineer · Build desk

Illustration accompanying NVIDIA's NVCRE runs the NCCL test that Slurm gets from a single srun command

What happened

  • NVIDIA has published the Cluster Readiness Engine, an open source Kubernetes controller that narrows a failure to the specific nodes involved before production workloads are scheduled onto them.
  • The failure it targets is a cluster where every GPU, network link and pod reports healthy while a 512-GPU training job still underperforms or fails outright.
  • The published sample report fails an all-reduce after 42 minutes 18 seconds across eight nodes, flagging gpu-node-07 for a threshold violation and gpu-node-12 for a detected hardware failure.

Compiled by The EngineerSomething wrong?How this is made

Why it matters

  • cost Certification spends cluster hours up front: the sample run held eight nodes at full scale for 42 minutes to produce two node names. The alternative bill is days of bisecting while capacity sits idle.
  • capability Teams that tracked stage progression in shell scripts and a spreadsheet can retire that layer and drive readiness from custom resources under GitOps instead.
  • constraint Because pass and fail are CEL expressions over measurements, each operator owns the definition of ready, so two clusters can report the same reason code against different bars.
  • precedent The example manifest is v1alpha1, so anyone committing these CRDs to a GitOps repository should expect the schema to change under them.

Three custom resources carry the design. You create a Certification that names the target nodes and the categories to run. It creates one Workflow per category, and each Workflow creates one Job [11].

The Workflow applies catalog, platform and GPU overrides, manages iteration count, and sets the orchestration target. The Job runs the workload on its node group, monitors node health, and records measurements and failures [10]. Results then travel back up: the Job records which nodes failed and why, the Workflow reports the category result, and the Certification groups results by category [11]. A degraded fabric link comes back as a node name and a reason code.

This got built because of a gap in Kubernetes. On Slurm the readiness test is one srun command, and Kubernetes has no built-in equivalent [8]. The same test there needs GPU and RDMA resource requests, NCCL settings matched to the network fabric, a large enough shared-memory volume, and a way to make all the pods start together [9]. Platform teams have been writing that themselves, usually shell scripts wrapped around NCCL tests, with a runbook or spreadsheet tracking which nodes cleared which stage [7].

The sample in the post is an example of the report format. That run fails communication/nccl-all-reduce after 42 minutes 18 seconds at full scale, eight nodes per job, with gpu-node-07 flagged ThresholdViolation and gpu-node-12 flagged HardwareFailureDetected [13]. Two of eight is 25 percent of the nodes in that job [18]. For the runtime to mean anything on your hardware you would need the same GPUs per node, the same fabric and the same iteration count, and NVCRE derives the first and third of those itself: it detects GPU architecture and cloud platform from the target nodes, then sets GPUs per node, the NCCL environment and platform networking accordingly [15]. The failure the post opens with is a 512-GPU training job [1], and the sample it prints covers eight nodes.

Pass and fail criteria are Common Expression Language expressions evaluated against the measurements [16]. Those expressions define what "ready" means, and the bar moves by stage: bring-up, burn-in, preproduction and production each set a different one, and a node that passes a smoke test is not necessarily ready to join a 512-GPU run [6]. The post does not print the threshold values.

The catalog covers five NCCL communication variants, the DCGM level-4 diagnostic suite, and NeMo pretraining with Nemotron 5 at 8B and 56B parameters, which is eight entries across three domains [14][19]. Because every resource is a CRD, the whole progression is inspectable with kubectl and drivable from GitOps [12]. NVIDIA's post says "Readiness becomes a proven property of the cluster rather than an assumption." On the published evidence it is a measured property of the nodes you paid to test, for the categories you chose, and the example manifest is still apiVersion nvcre.nvidia.com/v1alpha1 [20][17].

What to watch

  • Whether NVIDIA publishes the CEL threshold values, so operators can see what bar a ThresholdViolation was measured against.
  • Whether certification runtimes get reported at fleet scale, given that the published sample covers eight nodes per job.
  • Whether the catalog grows past three domains, and which cloud platforms the detection step actually recognises.
Loading claim ledger
Loading source directory links
Loading share composer
Loading topic controls
Loading related stories