CCNA Administration Questions

The file system client must support cuFile and be mounted appropriately for direct memory access. Without cuFile support, applications cannot use the GPUDirect Storage path. Mount options and client capabilities determine whether the storage stack can perform peer-to-peer transfers to GPU memory.

The head node in Base Command Manager is the central management server that handles node discovery, provisioning, and configuration. It runs services like DHCP, TFTP, and the provisioning engine that automatically detect new nodes when they PXE boot. It then applies the appropriate image and configuration. This is the core component for automating cluster setup, making it the correct answer for node discovery and initial configuration.

The GPU Operator deploys its components into the gpu-operator namespace by default, and the field selector spec.nodeName filters pods to a specific node. This command directly lists the operator pods on the target node, allowing the administrator to confirm that components such as the driver daemonset, container toolkit, and device plugin are running. It is the precise and efficient way to verify operator deployment on a worker node.

Base Command Manager allows administrators to define node groups and assign software images that include specific GPU driver and CUDA toolkit versions. During provisioning, nodes in the group automatically receive the defined software stack, ensuring consistency. This automation reduces manual configuration errors and ensures all compute nodes have the correct versions for AI workloads.

DCGM Exporter is designed to collect GPU metrics using DCGM and expose them in Prometheus format. It runs as a container and provides metrics such as GPU utilization, memory usage, temperature, and power. These metrics can be scraped by Prometheus and stored in a time-series database for analysis. This is the standard solution for exporting GPU telemetry in Kubernetes environments.

For Kubernetes to schedule workloads onto MIG instances, the NVIDIA device plugin must advertise each MIG slice as a schedulable resource, which the GPU Operator configures via its MIG strategy setting. Without this, MIG instances exist on the GPU but are invisible to the scheduler. Enabling the device plugin to expose MIG resources is therefore a necessary action to make tenant isolation effective.

The NVIDIA driver requires access to specific device nodes under /dev/nvidia* to function. By denying access to these files, the runtime prevents the container's CUDA libraries from establishing a connection to the GPU driver, rendering the GPU invisible to the application code executing inside the container environment.

DCGM is designed for data center GPU monitoring and management at scale. It provides real-time temperature, power, and health metrics for each GPU and can be integrated with monitoring systems. For fleet-wide temperature monitoring and throttle detection, DCGM is the appropriate tool in this scenario.

Distributed training performance is highly sensitive to the communication stack. Inconsistent NCCL versions can lead to suboptimal collective operation performance, while mismatched drivers can cause compatibility issues with the underlying hardware interconnects, ultimately leading to performance degradation and difficult-to-debug failures during large-scale model training cluster operations.

This command shows detailed node status, including conditions, capacity, and allocatable resources. If the GPU Operator's device plugin is not functioning, the node will report zero allocatable nvidia.com/gpu resources, and events may indicate plugin registration failures. It directly reveals whether the node recognizes the GPUs as schedulable resources, making it the essential first diagnostic step.

XID 74 and 79 are associated with GPU falling off the bus and NVLink errors respectively. The correct administrative response is to collect detailed GPU and NVLink state with `nvidia-smi -q`, run DCGM diagnostics to isolate the failing GPU or link, and then perform hardware remediation such as reseating the GPU board or replacing it if diagnostics confirm a persistent fault.

Setting NCCL_DEBUG=INFO generates detailed logs that show which transports NCCL uses, including whether GPUDirect RDMA is active. The logs will indicate if the network plugin is using RDMA and if there are any fallbacks to slower paths. This is the standard method to verify NCCL's behavior and diagnose performance issues related to network communication.

The DCGM Exporter is purpose-built for this task. It collects detailed telemetry, such as power, temperature, and usage, directly from the GPUs via DCGM and makes it available to monitoring platforms. This provides a clean, automated, and scalable architecture for centralized tracking of GPU performance metrics across the cluster.

Base Command Manager supports integration with enterprise identity providers such as LDAP or Active Directory for authentication and authorization. Enabling audit logging captures job submission events and user actions. Together, these features enforce authorized access and provide the required audit trail for job submissions in this scenario.

DCGM is the NVIDIA tool designed for data center GPU monitoring and management. It collects health, utilization, power, temperature, and ECC metrics, and the DCGM exporter exposes them to Prometheus for centralized dashboards and long-term retention. This directly matches the requirement for fleet-wide GPU telemetry and historical capacity planning data.

An InfiniBand port remains in INIT when it has not been initialized by a subnet manager, so checking that the subnet manager service is active on the fabric and that IPoIB (or RDMA) interfaces are up is the correct first diagnostic step. Without subnet manager configuration, ports never transition to ACTIVE and inter-node bandwidth collapses regardless of GPU or driver health.

MIG hardware partitions ensure that each workload receives a dedicated set of compute units and memory buffers. By physically isolating the GPU resources, you guarantee deterministic performance for each tenant, which is necessary when running sensitive or high-throughput AI training models concurrently on a single hardware accelerator.

Pod events reveal whether the scheduler rejected the pod due to missing nvidia.com/gpu or nvidia.com/mig-* resources. If the device plugin advertises MIG profiles but the workload requests a full GPU (or vice versa), the pod stays Pending. Checking the MIG strategy and node labels directly addresses this common scheduling mismatch.

DCGM is designed for centralized GPU telemetry, health monitoring, and policy enforcement in data center environments. BCM integrates with DCGM to collect metrics from all nodes and can forward them to monitoring systems like Prometheus for alerting. Configuring DCGM within BCM provides the required centralized collection and threshold-based alerts for temperature and other metrics.

When Prometheus is managed by the Prometheus Operator, it only scrapes targets whose ServiceMonitor or PodMonitor labels match the operator's serviceMonitorSelector or podMonitorSelector. If the DCGM Exporter's monitor labels do not match, Prometheus silently ignores the endpoint even though the exporter is running. Verifying selector label alignment is the correct first step because it is the most common cause of missing metrics in operator-managed Prometheus.

NVIDIA Confidential Computing utilizes hardware-based Trusted Execution Environments (TEEs) to encrypt data while it resides in GPU memory. This prevents unauthorized access from other processes, the kernel, or the hypervisor, ensuring that sensitive model weights remain secure even if the software environment is considered untrusted or potentially compromised.

DCGM policy management allows administrators to define policies that trigger actions when health violations occur, such as resetting a GPU or cordoning a node. This enables automated mitigation, reducing downtime. It works in conjunction with health checks. Configuring policies ensures that detected issues are handled promptly, which is essential for proactive health management in a large GPU cluster.

The GPU Operator's device plugin exposes GPUs as schedulable resources (nvidia.com/gpu). Enforcing a policy that requires pods to request this resource ensures that only pods explicitly asking for GPUs receive device nodes. Forbidding privileged mode enforces least privilege. Together, these configurations ensure GPU device nodes are not exposed to pods that do not request them and that pods run with minimal privileges.

GDS relies on RDMA and peer-to-peer (P2P) communication to transfer data directly between storage and GPU memory without CPU involvement. The storage devices (NVMe over Fabrics) and network adapters (InfiniBand) must support RDMA, and the system must be configured to allow P2P DMA. This includes enabling PCIe Access Control Services (ACS) and IOMMU settings that permit direct peer-to-peer transfers. Without this, GDS cannot achieve direct data paths.

A ValidatingAdmissionWebhook can intercept pod creation requests and evaluate custom logic, such as checking for a specific label before allowing the pod to request GPU resources. This provides the flexibility to enforce label-based policies on extended resources. By deploying a webhook that inspects pod labels and resource requests, the administrator can deny non-compliant pods, meeting the requirement.

DCGM provides comprehensive GPU health monitoring, and its integration with Slurm via the health check plugin allows automatic detection of unhealthy GPUs. When DCGM identifies a failed GPU, the plugin can drain the node from Slurm, preventing new jobs from being scheduled on it. This directly addresses the requirement to schedule only on healthy GPUs and automatically remove failed ones.

The nvidia-smi tool is specifically designed to provide a comprehensive view of all NVIDIA GPUs installed in the system. It displays critical health metrics like power usage, temperature, memory usage, and compute utilization in a real-time format, serving as the primary diagnostic tool for AI infrastructure administrators.

Base Command Manager health checks can run custom scripts periodically. A script can query GPU temperature and, if over threshold, call the Base Command Manager API to drain the node. An alert rule then sends a notification. This provides automated remediation and alerting as required.

The GPU Operator deploys its components into the gpu-operator namespace by default. Running kubectl get pods -n gpu-operator lists all pods in that namespace, allowing the administrator to see if the operator, driver, container toolkit, device plugin, and other components are running. This is the standard way to verify the operator's deployment status.

SYS indicates that communication between those two GPUs traverses the system's PCIe and CPU interconnect instead of the high-speed NVLink/NVSwitch fabric. On a DGX H100, all GPU pairs should normally show NV18 via NVSwitch, so this points to a degraded or missing NVLink path between GPU4 and GPU5 that must be investigated.

MIG allows a physical GPU to be partitioned into multiple isolated instances at the hardware level. Each instance has its own dedicated memory and compute resources, providing the isolation necessary for multi-tenant environments where security and performance guarantees are required for concurrent, independent workloads on a single piece of hardware.

Running nccl-tests with debug logging reproduces the collective communication pattern outside the training job. It reveals which transport (InfiniBand, RoCE, or sockets) is used, whether topology detection fails, and where timeouts occur. This isolates NCCL configuration issues from fabric problems before deeper network diagnostics.

The NVIDIA Container Toolkit is essential for enabling the container runtime to interact with the host's NVIDIA drivers. It performs the necessary steps to inject the GPU devices into the container namespace and ensures that the required libraries are mapped correctly so the application can communicate with the GPU hardware.

A MutatingAdmissionWebhook can intercept pod creation requests and automatically modify the pod specification to add environment variables when the pod requests GPU resources. This enforces the policy cluster-wide without requiring manual changes to each pod. It is a standard Kubernetes mechanism for such automation and integrates well with the GPU Operator's resource requests.

Proactively updating the OS and drivers to versions that support the upcoming GPU hardware ensures that when the physical installation occurs, the software stack is ready. This minimizes the time spent troubleshooting driver incompatibilities and allows for a smooth, plug-and-play integration of the new hardware into the production cluster.

Pod disruption budgets (PDBs) ensure that a specified minimum number of pods remain available during voluntary disruptions, such as node drains or upgrades. This helps maintain service availability for critical inference workloads. By defining a PDB, the administrator can prevent simultaneous eviction of too many replicas, thus supporting high availability.

Run:ai projects enforce a GPU quota per project. Even if the cluster has idle GPUs, a job in a project that has already consumed its quota will remain Pending until quota is freed. This matches the scenario where the cluster shows free GPUs but the job cannot start because the project-level quota is the limiting factor.

NVIDIA DCGM Exporter is a Prometheus exporter that collects GPU metrics using NVIDIA Data Center GPU Manager (DCGM) and exposes them in a format that Prometheus can scrape. It provides a wide range of metrics, including utilization, temperature, power, and memory usage, making it ideal for centralized monitoring of large GPU clusters.

Kubernetes ResourceQuota objects can limit the aggregate quantity of extended resources, such as nvidia.com/gpu, that can be requested within a namespace. By defining a ResourceQuota that specifies a maximum for nvidia.com/gpu, the administrator can enforce GPU quotas across namespaces. This is the native Kubernetes mechanism for quota enforcement and works in conjunction with the NVIDIA device plugin that advertises GPUs as extended resources.

The nvidia-smi command queries the NVIDIA driver and displays detailed information about all installed GPUs, including the GPU model, driver version, CUDA version, and current utilization. It is the standard tool for verifying driver and CUDA compatibility on a GPU-enabled system, making it the correct choice for this scenario.

Rolling updates ensure that the cluster remains operational throughout the entire upgrade process. By draining one node at a time, the administrator can safely update drivers without terminating active workloads prematurely. This approach provides a clear path for verification and rollback if the update encounters any unforeseen compatibility issues.

By disabling P2P, the system is forced to move data through the PCIe bus or system memory, which is significantly slower than using NVLink or direct P2P access. This causes a major bottleneck in collective operations like AllReduce, which are fundamental to the scalability of distributed AI training jobs.

High GPU utilization accompanied by low throughput indicates the GPU is spending time waiting for data to arrive from the CPU or storage. This starvation effect is a classic symptom of an inefficient data loader or slow storage subsystem, which limits the overall throughput despite the GPU's apparent activity.

NVIDIA vGPU allows a single physical GPU to be partitioned into multiple virtual GPUs, each assigned to a different VM. This enables sharing and maximizes utilization. It requires vSphere with NVIDIA vGPU software and compatible GPUs. This is the correct feature for GPU sharing in vSphere.