Recommended Free Tools
Short answer: Run:ai v3.0 supports upstream Kubernetes 1.35–1.37 with containerd, or Red Hat OpenShift 4.20–4.22 with CRI-O, on x86 or ARM. Amazon EKS, Google GKE, Microsoft AKS, Oracle OKE and RKE2 are supported when the underlying Kubernetes release falls within that range. You also need NVIDIA GPU Operator 25.10–26.7.1, Prometheus, supported Linux nodes, synchronized clocks, shared storage, cluster-administrator access, and network services such as ingress, DNS, TLS and a load balancer. vGPU, NVIDIA DGX Spark, Jetson and workstation deployments are not supported; Run:ai uses GPU passthrough.
Run:ai v3.0 Kubernetes compatibility
The first compatibility gate is the cluster control plane and its container runtime. NVIDIA’s Run:ai v3.0 support matrix lists the following combinations:
As an Amazon Associate I earn from qualifying purchases.
| Environment | Supported version | Container runtime | CPU architecture |
|---|---|---|---|
| Upstream Kubernetes | 1.35–1.37 | containerd | x86 and ARM |
| Red Hat OpenShift | 4.20–4.22 | CRI-O | x86 and ARM |
| Amazon EKS | Supported when based on a Kubernetes release in the upstream range | Provider configuration must meet the supported runtime requirements | Check the exact EKS release and architecture |
| Google GKE | Supported when based on a Kubernetes release in the upstream range | Provider configuration must meet the supported runtime requirements | Check the exact GKE release and architecture |
| Microsoft AKS | Supported when based on a Kubernetes release in the upstream range | Provider configuration must meet the supported runtime requirements | Check the exact AKS release and architecture |
| Oracle OKE | Supported when based on a Kubernetes release in the upstream range | Provider configuration must meet the supported runtime requirements | Check the exact OKE release and architecture |
| RKE2 | Supported when based on a Kubernetes release in the upstream range | Verify the runtime for the selected RKE2 release | Check the exact node architecture |
“Supported” for a managed service does not mean that every provider release is immediately available in every region. Confirm that your provider offers the required Kubernetes minor version before scheduling an upgrade. Run:ai compatibility cannot make a provider version installable if the cloud service has not released it.
PC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteHow to check the cluster before installation
- Run
kubectl versionand record the server version, not just the client version. The server must be within Kubernetes 1.35–1.37 for an upstream deployment. - Identify the runtime on representative GPU and control-plane nodes, for example with
kubectl get nodes -o wideand your provider’s node-details command. Upstream deployments require containerd; OpenShift deployments require CRI-O. - Record whether nodes are x86 or ARM. Both architectures are listed, but every image, GPU driver and framework you plan to run must also publish an image for that architecture.
- Check the exact Run:ai release matrix again if you are evaluating a different major or minor release. OpenShift and managed-cloud support must not be inferred from another release’s table.
GPU Operator, drivers and monitoring prerequisites
NVIDIA states that a Run:ai cluster requires NVIDIA GPU Operator to be installed on the Kubernetes cluster. For Run:ai v3.0, the supported GPU Operator range is 25.10–26.7.1. The operator version also determines which NVIDIA data-center GPU models are supported, so there is no single universal minimum GPU model published for Run:ai.
Match the GPU model to the operator
Use the GPU Operator’s supported data-center GPU list for the precise model, firmware and driver combination. Then check the CUDA and framework matrix for the workloads you intend to run. A GPU can pass the operator check and still be unsuitable for a particular CUDA, PyTorch, TensorFlow or NVIDIA NIM release. Treat those as separate gates rather than assuming that Run:ai support automatically covers every framework.
Install monitoring before Run:ai
Prometheus is a baseline prerequisite. The v3.0 matrix lists Prometheus 3.13.1 or the Kube-Prometheus Stack 88.6.5 and later. Monitoring is used for cluster and GPU telemetry, so installing it after the Run:ai components can leave an incomplete deployment or missing metrics.
Check the installed chart and application versions, not only the Kubernetes objects’ names. Helm output, Prometheus custom resources and the operator status should all show a healthy, ready state before you apply Run:ai charts.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Special GPU features and their extra requirements
GPU fractions
GPU fractions have a narrower support envelope than ordinary GPU allocation. You need all three conditions:
- NVIDIA GPU Operator 26.7.1 or later.
- An NVIDIA CUDA driver at r615 or later.
- NVIDIA Runtime Interface (NRI) disabled by setting
cdi.nriPluginEnabled=false.
Apply the NRI setting according to the GPU Operator configuration method for your release, then verify the rendered configuration and restart affected components if the operator requires it. If any one of these conditions is missing, test a normal whole-GPU workload first; do not diagnose fractional allocation from a partially upgraded node.
RDMA and Multi-Node NVLink
Nodes that use RDMA or Multi-Node NVLink need the NVIDIA Network Operator. Multi-Node NVLink configurations may also use Kubernetes Dynamic Resource Allocation (DRA) for the applicable resource claims. DRA is not a blanket requirement for every GPU cluster; it applies to the supported Multi-Node NVLink designs.
The prerequisite sheet lists Kubernetes 1.32 or later and GPU Operator 25.3 or later for Multi-Node NVLink. Run:ai v3.0’s general upstream range starts at Kubernetes 1.35, so a v3.0 installation already clears that Kubernetes floor. You still must satisfy the v3.0 GPU Operator range and install Network Operator where the topology requires it.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Rank #2
- Part number 900-53651-2500-000 and model: P3651
- This is the 2 slot version for when there is no empty slots between 2 slot cards. If you have one or more empty slots between the cards or the cards are 3 slot this NVLink will not work. See the attached images showing the card layout.
- NVLink 3.0 for any brand of RTX Ampere model graphics cards: 3090, A30, A40, A100 / H100 (Requires three NVLinks), A800, A4500, A5000, A5500, A6000
- This is the same as PNY part number: NVLAMP-2SLOT-BSP and RTXA6000NVLINK-KIT
- This is the same as Dell part number: 0RWJ7Y
Node, operating-system and runtime requirements
Supported Linux and time synchronization
Use a Linux distribution supported by both your Kubernetes distribution and the NVIDIA GPU Operator. The overlap matters: a node can be valid for Kubernetes but unsupported by the GPU driver, or vice versa.
Synchronize every control-plane and worker node with NTP. Clock drift can produce misleading certificate, token, lease and telemetry failures. Verify the time source and synchronization state on all nodes, including newly autoscaled GPU workers, rather than checking only one machine.
Permissions and container runtime
The installation operator needs cluster-admin permissions. A restricted role that can create namespaces but cannot install cluster-scoped custom resource definitions, webhooks or drivers will fail partway through. Plan the access window with the cluster owner and remove temporary privileges only after installation and validation are complete.
Configure a supported container runtime before adding GPU workloads. Runtime configuration must be consistent with the selected Kubernetes distribution: containerd for the listed upstream deployment and CRI-O for the listed OpenShift deployment. Confirm that the NVIDIA runtime hooks and device access work on a test GPU node before troubleshooting Run:ai scheduling.
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Storage, ingress and network access
Storage classes and shared worker storage
Configure a default storage class for the control plane. Run:ai worker nodes also need shared storage reachable from every worker. A disk attached to only one node is not shared storage and can cause jobs, artifacts or control components to fail when rescheduled.
- Confirm that a default storage class exists and can dynamically provision a small test volume.
- Verify that every Run:ai worker can mount the shared storage using the same path and access policy.
- Test a pod restart on another worker to prove that data remains available after rescheduling.
- Check capacity, read/write mode and network throughput against your training workload; a technically mountable volume can still bottleneck distributed jobs.
Load balancing, ingress and DNS
Prepare a load balancer and ingress controller, then assign a DNS-resolvable fully qualified domain name (FQDN) for the Run:ai services. Obtain TLS certificates that cover the FQDN and configure the ingress to present the complete certificate chain. Internal-only clusters still need consistent name resolution from administrator workstations, cluster nodes and any external identity or registry services that the installation contacts.
Validate the path end to end: resolve the FQDN from a client network, connect on the required HTTPS port, inspect the certificate name and chain, and confirm that the ingress routes to a healthy service. A working Kubernetes service with a broken external DNS record is not a working Run:ai installation.
Rank #3
- Video/Sound Cards
- Passive Cooling
Registries, firewalls and critical services
Allow the nodes and control-plane components to reach the container registries and critical services required by your chosen installation method. Corporate firewalls, private registries and proxy policies often block image pulls even when the cluster itself is healthy.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Repair Windows errors before they cause bigger problems3Scan for outdated or missing drivers - takes under a minuteCreate the allowlist before installation, including DNS, registry authentication endpoints, certificate authorities and any identity or telemetry endpoints used in your deployment. If the cluster is air-gapped, confirm that every required image and chart is mirrored and that image references are rewritten consistently; the compatibility matrix alone does not certify an air-gapped process.
Guided installation versus manual Helm deployment
Guided installation
The guided workflow can install or configure several prerequisites, which is useful when you control the cluster and want the installer to perform standard setup. It does not remove the need to verify provider version availability, GPU model support, network policy, certificates, shared storage or organizational approval for cluster-admin access.
Manual Helm installation
With a manual Helm deployment, infrastructure and prerequisites must be ready before charts are applied. This approach is preferable when platform teams centrally manage the GPU Operator, Prometheus, ingress, storage or private registries. Document the exact chart versions and values, then validate each dependency independently so a failed Run:ai release is not masking an operator or networking problem.
- Freeze the target Kubernetes or OpenShift version and confirm it appears in the Run:ai v3.0 matrix.
- Install and validate GPU Operator, including driver readiness on every GPU node.
- Install Prometheus or the supported Kube-Prometheus Stack version and confirm targets are being scraped.
- Add Network Operator and any DRA configuration required by RDMA or Multi-Node NVLink.
- Configure storage, ingress, DNS, TLS and registry access.
- Apply the Run:ai charts with cluster-admin credentials, then inspect pods, custom resources, events and logs.
- Run a small GPU passthrough workload before enabling advanced scheduling features such as GPU fractions or multi-node networking.
Unsupported deployments and common compatibility traps
vGPU is unsupported
Run:ai supports GPU passthrough only. A virtual GPU (vGPU) presentation is outside the supported matrix, even if the guest operating system can see a CUDA device. Use physical GPU passthrough on supported data-center hardware instead.
Unsupported NVIDIA platforms
NVIDIA DGX Spark, NVIDIA Jetson and workstation platforms are unsupported for this Run:ai deployment. Do not extrapolate from a successful standalone CUDA test on one of these systems to a supported Kubernetes cluster.
Mixing version ranges
Do not combine a Kubernetes version from one Run:ai release with a GPU Operator range taken from another. The v3.0 matrix’s GPU Operator range is 25.10–26.7.1, while the separate Multi-Node NVLink prerequisite mentions GPU Operator 25.3 or later. For a v3.0 cluster, satisfy the stricter v3.0 range and then verify the topology-specific requirements.
Rank #4
- CUDA Cores: 4608 / NVIDIA Tensor Cores: 576 / NVIDIA RT Cores: 72
- GPU Memory: 24 GB GDDR6 with ECC / Bandwidth: 624 GB/Sec
- System Interface: PCI Express 3.0 x16
- Four DisplayPort 1.4 Connectors
- 3D Stereo Support with Stereo Connector
Assuming hardware support from the product name
There is no universal Run:ai minimum GPU model. Check three lists for the exact card: the GPU Operator’s data-center GPU support, the CUDA driver and CUDA toolkit support, and the framework or NIM support for your workload. A mismatch at any layer can prevent scheduling or cause runtime errors.
A practical preflight checklist
- Cluster: Kubernetes 1.35–1.37 with containerd, or OpenShift 4.20–4.22 with CRI-O; managed services must actually offer the selected release.
- Architecture: x86 or ARM nodes with images and drivers available for that architecture.
- GPU: Data-center NVIDIA GPUs listed by the selected GPU Operator; physical passthrough rather than vGPU.
- Operators: GPU Operator 25.10–26.7.1 and Prometheus 3.13.1 or Kube-Prometheus Stack 88.6.5 or later.
- Advanced networking: Network Operator for RDMA or Multi-Node NVLink; DRA where the NVLink design calls for it.
- Fractional GPUs: GPU Operator 26.7.1 or later, CUDA driver r615 or later and
cdi.nriPluginEnabled=false. - Nodes: Linux supported by both Kubernetes and GPU Operator, NTP synchronization and a configured runtime.
- Access: Cluster-admin permissions for installation.
- Storage: A default control-plane storage class and shared storage reachable from every Run:ai worker.
- Network: Load balancer, ingress, DNS-resolvable FQDN, valid TLS certificates and firewall or registry allowlists.
- Workloads: Separate validation of CUDA, PyTorch, TensorFlow, NIM or other framework compatibility for the target GPU architecture.
What to do when installation fails
Images will not pull
Check DNS resolution from the node, registry credentials, proxy settings, firewall rules and the certificate chain trusted by the container runtime. Compare the failing image’s registry and tag with the mirrored or approved image list.
GPUs are absent from nodes
Inspect GPU Operator pods, node labels, device-plugin logs and driver readiness. Confirm that the model is on the operator’s data-center support list and that the node is using physical passthrough. Do not troubleshoot Run:ai scheduling until a plain Kubernetes GPU pod can access the device.
Metrics or dashboards are empty
Verify the Prometheus or Kube-Prometheus Stack version, service discovery, scrape targets, network policies and time synchronization. Missing metrics can be a monitoring configuration issue rather than a scheduler failure.
Multi-node jobs cannot form a fabric
Confirm that the nodes have the required Network Operator configuration, RDMA or NVLink hardware, compatible drivers and the applicable DRA resources. Check that the Kubernetes version and GPU Operator meet the Multi-Node NVLink prerequisites before examining application-level errors.
Fractional allocation is rejected
Recheck all three fractional-GPU conditions: GPU Operator 26.7.1 or newer, CUDA driver r615 or newer and NRI disabled with cdi.nriPluginEnabled=false. Inspect the operator’s effective configuration rather than relying on a values file that may not have been applied.
The Bottom Line
For Run:ai v3.0, build the cluster around the support matrix first: Kubernetes 1.35–1.37 or OpenShift 4.20–4.22, the matching runtime, GPU Operator 25.10–26.7.1, Prometheus, supported physical NVIDIA GPUs, shared storage and complete ingress, DNS, TLS and registry connectivity. Treat GPU fractions, RDMA and Multi-Node NVLink as additional compatibility projects, and exclude vGPU, DGX Spark, Jetson and workstation deployments.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
