Question bank
NVIDIA Certified Professional - AI Operations
42 NVIDIA Certified Professional - AI Operations questions with the correct answer and a written explanation, organised across 4 exam domains.
- 42 questions
- 4 domains
- Foundation level
certilumQuestion index
Jump straight to any question. Answers and explanations are inline.
AI Cluster Installation and Deployment Skills
12 questions in this domain
- Question 1Single Choice
Where must the NVIDIA driver be installed on a cluster to support GPU workloads in containers?
- AHost machineCorrect answer
- BInside the container image
- CIn the Docker daemon
- DOn a remote driver server
Why this is the answer
The NVIDIA driver must be installed on the host OS; containers use it through the NVIDIA Container Toolkit.
- Question 2Multiple Select
Which statements about the installation and runtime location of the NVIDIA driver for GPU containers are correct?
- ADriver must be on the host OS.Correct answer
- BContainer image should include kernel driver.
- CGPU containers depend on the host driver.Correct answer
- DDriver can be loaded only inside the container.
Why this is the answer
GPU containers rely on the host-installed NVIDIA driver at runtime; the image only needs user-space CUDA libraries.
- Question 3Interactive
The Dockerfile shown attempts to install the NVIDIA driver inside the image. What is the primary problem with this approach?
- ADriver must reside on the host machine.Correct answer
- BUse latest tag instead.
- CDocker provides full security isolation.
- DContainer cannot run because it lacks a scheduler.
Why this is the answer
The NVIDIA driver must reside on the host machine; installing it inside the Docker image does not enable GPU access.
- Question 4Single Choice
Why is relying on the 'latest' tag risky for GPU container images in AI cluster deployments?
- ALatest always points to a stable release.
- BThe tag can move to a newer version.Correct answer
- CLatest cannot be used with CUDA images.
- DLatest prevents checkpointing from working.
Why this is the answer
The 'latest' tag is volatile and can point to a different image version over time, causing inconsistent deployments.
- Question 5Multiple Select
Which two practices help avoid image tag volatility when deploying AI containers in a cluster?
- APin images by digest.Correct answer
- BUse immutable version tags.Correct answer
- CAlways use the latest tag.
- DRemove tags after building.
Why this is the answer
Pinning by digest or using immutable version tags ensures the exact image content is used for reproducible deployments.
- Question 6Interactive
The Dockerfile references an image tag in its base image instruction. Which deployment concern does this introduce?
- AMissing host driver
- BImage tag volatilityCorrect answer
- CUnsecured multi-tenant boundary
- DInsufficient GPU scheduling
Why this is the answer
Using a mutable tag such as 'latest' creates image tag volatility because the referenced image can change unexpectedly.
- Question 7Single Choice
Why is Docker not considered a complete security boundary for container workloads in multi-tenant AI clusters?
- ASame isolation as a hypervisor.
- BContainers share the host kernel.Correct answer
- CDocker prevents all host-level access.
- DDocker automatically isolates tenants.
Why this is the answer
Docker containers share the host kernel, so additional security controls are required for isolation in multi-tenant clusters.
- Question 8Multiple Select
Which additional Kubernetes security measures are needed to enforce full multi-tenant isolation in containerized AI clusters?
- AEnforce Pod Security Standards.Correct answer
- BUse Kubernetes namespaces.Correct answer
- CRun containers without privilege escalation.Correct answer
- DTrust Docker's default isolation only.
Why this is the answer
Multi-tenant clusters require namespace isolation, pod security standards, and non-privileged containers because Docker's default isolation is insufficient.
- Question 9Interactive
The Kubernetes manifest runs a privileged container. In a shared AI cluster, why is this a concern despite Docker's isolation?
- APrivileged containers can access host resources.Correct answer
- BThe latest tag may change.
- CThe GPU driver is missing.
- DCheckpointing is not enabled.
Why this is the answer
A privileged container has broad access to host resources, weakening tenant isolation and increasing risk in shared clusters.
- Question 10Single Choice
In an AI cluster, what distinguishes scaling from scheduling when managing compute resources and workloads?
- AScaling adds resources; scheduling assigns workloads.Correct answer
- BScaling assigns workloads; scheduling adds nodes.
- CBoth describe driver installation.
- DScaling is a security control.
Why this is the answer
Scaling changes cluster capacity by adding or removing resources, while scheduling places workloads on available nodes and GPUs.
- Question 11Multiple Select
Which statements correctly describe how scaling and scheduling are used to manage AI cluster resources?
- AScaling changes cluster capacity.Correct answer
- BScheduling places workloads on nodes.Correct answer
- CAutoscaling adjusts capacity based on demand.Correct answer
- DScaling and scheduling are identical.
Why this is the answer
Scaling changes capacity, scheduling assigns workloads to resources, and autoscaling adjusts capacity automatically based on demand.
- Question 12Interactive
The provided manifest defines an autoscaler. Which cluster behavior does this Kubernetes object control?
- AScalingCorrect answer
- BScheduling
- CCheckpointing
- DSecurity
Why this is the answer
A HorizontalPodAutoscaler controls scaling by adjusting the number of replicas in response to resource usage.
Cluster Administration
10 questions in this domain
- Question 13Single Choice
In a GPU-accelerated container deployment, where must the NVIDIA kernel driver be installed for the GPUs to work?
- AInside the container image
- BOn the host operating systemCorrect answer
- CIn a Kubernetes ConfigMap
- DOn a shared network filesystem
Why this is the answer
The NVIDIA driver must be installed on the host; containers use the driver through the container runtime instead of bundling the kernel driver.
- Question 14Multiple Select
Which practices help prevent reproducibility problems caused by the volatile 'latest' image tag in GPU workloads?
- APin images to a specific version or digestCorrect answer
- BUse an immutable registry that prevents tag overwritesCorrect answer
- CReview image changes before allowing updatesCorrect answer
- DAlways select images tagged 'latest' to get fixes
Why this is the answer
The 'latest' tag is a mutable pointer; using a digest or fixed version and immutable registries ensures a deployment remains reproducible.
- Question 15Interactive
The command shown in the code block changes the number of running instances. Which operational concept does this represent?
- AScalingCorrect answer
- BScheduling
- CCheckpointing
- DPreemption
Why this is the answer
Scaling changes the number of replicas, while scheduling decides where those replicas are placed.
- Question 16Single Choice
When running containers in a multi-tenant GPU cluster, why is Docker by itself not considered a strong security boundary?
- AContainers share the host kernel and can be affected by privilege escalationCorrect answer
- BDocker completely isolates all hardware resources
- CContainers are virtual machines with hypervisor isolation
- DDocker automatically encrypts inter-container traffic
Why this is the answer
Containers share a host kernel; Docker alone does not enforce tenant isolation, so additional security controls are required.
- Question 17Multiple Select
Which conditions are necessary to make a GPU workload resumable after a node is preempted?
- AThe application supports checkpoint and restoreCorrect answer
- BCheckpoints are written to persistent or shared storageCorrect answer
- CThe workload uses the 'latest' image tag
- DThe GPU driver is installed only in the container
Why this is the answer
The application must be able to save state, and that state must survive preemption on persistent storage, for resumption to work.
- Question 18Interactive
The command in the code block reports the connection layout of GPUs. Which administrative concern does it address?
- AHardware topology awarenessCorrect answer
- BContainer image reproducibility
- CMulti-tenant security isolation
- DGPU driver installation path
Why this is the answer
The nvidia-smi topo -m command displays GPU and NVLink/PCIe topology, helping the scheduler place jobs based on actual hardware connections.
- Question 19Single Choice
Which component is responsible for loading the NVIDIA kernel driver on a GPU cluster node?
- AHost OS kernel moduleCorrect answer
- BDocker image layer
- CKubernetes dashboard plugin
- DContainer runtime plugin
Why this is the answer
The host kernel module is loaded by the node's operating system. The NVIDIA container runtime depends on that host driver.
- Question 20Multiple Select
Which statements correctly describe the role of scheduling in a Kubernetes cluster?
- ADecides which node will run a pending podCorrect answer
- BConsiders resource requests and node constraintsCorrect answer
- CChanges the desired number of pod replicas
- DPerforms the same function as horizontal scaling
Why this is the answer
The Kubernetes scheduler assigns pods to nodes based on resource requirements and constraints; scaling adjusts replica counts.
- Question 21Interactive
The container launch command in the code block is expected to use GPUs. What must be true about the host for this to succeed?
- AThe NVIDIA driver must be installed on the host OSCorrect answer
- BThe NVIDIA driver must be included inside the container image
- CThe Kubernetes scheduler must be restarted
- DThe container must use a virtual GPU
Why this is the answer
The container runtime requires a host-installed NVIDIA driver; the kernel driver is not installed inside the container.
- Question 22Single Choice
Which image reference is the most reproducible for a GPU job in production?
- AA content-based image digestCorrect answer
- BThe 'latest' tag
- CThe date the image was pushed
- DThe image registry hostname only
Why this is the answer
A content-based digest is an immutable identifier for a specific image; tags are mutable and can be overwritten.
Troubleshooting and Optimization
10 questions in this domain
- Question 23Single Choice
In a Kubernetes cluster with GPU nodes, where must the NVIDIA kernel driver be installed when running containerized AI workloads?
- AOn the host operating systemCorrect answer
- BInside the container image
- CIn the container runtime's user namespace
- DOn a mounted network filesystem
Why this is the answer
The NVIDIA driver is a kernel module that must match the host kernel. GPU containers only need CUDA libraries and the NVIDIA Container Toolkit.
- Question 24Multiple Select
Which two components are required on a host to run NVIDIA GPU containers with the NVIDIA Container Toolkit?
- ANVIDIA driver installed on the hostCorrect answer
- BNVIDIA Container Toolkit configuredCorrect answer
- CThe latest container image tag
- DA hypervisor such as KVM
Why this is the answer
The host needs the NVIDIA driver and the NVIDIA Container Toolkit. The container image can carry CUDA libraries, but the kernel driver and runtime integration belong on the host.
- Question 25Interactive
Review this Dockerfile. What is the main reason the installed driver package will not work as intended in a container?
- AKernel driver cannot load inside a containerCorrect answer
- BContainer GPU memory is too small
- CImage tag must be latest
- DDriver requires internet access at runtime
Why this is the answer
Container images share the host kernel, so a kernel driver package installed inside a container cannot load. The driver must be present on the host and matched to the host kernel.
- Question 26Single Choice
Why is relying on an image tagged 'latest' risky for production NVIDIA GPU workloads in a shared cluster?
- AIt may point to a different imageCorrect answer
- BIt always builds the smallest image
- CIt does not support CUDA
- DIt cannot run on Kubernetes
Why this is the answer
A mutable tag like 'latest' can move to a newer build, making the environment different from the one used during validation.
- Question 27Multiple Select
Which two practices help prevent reproducibility problems caused by mutable container tags in GPU deployments?
- APin the image by digestCorrect answer
- BUse a specific version tagCorrect answer
- CAlways use the latest tag
- DStore images only in local cache
Why this is the answer
Pinning to a digest or a specific version tag guarantees the same image is used. Mutable tags and local cache are not reliable for reproducibility.
- Question 28Interactive
This Kubernetes Deployment uses a mutable image reference for its GPU workload. Which risk should the operator identify?
- AThe image can change without a version changeCorrect answer
- BThe container will not schedule on GPU nodes
- CThe Deployment will scale to zero
- DThe driver is installed in a sidecar
Why this is the answer
The 'latest' tag is mutable, so a redeploy can pull a different version of the image, leading to unreproducible behavior.
- Question 29Single Choice
Why is a Docker container not considered a strong security boundary for untrusted multi-tenant GPU workloads on shared infrastructure?
- AContainers share the host kernelCorrect answer
- BContainers have a separate kernel
- CImages include security patches
- DDocker blocks all host device access
Why this is the answer
Docker containers use the host kernel. If a container escapes, the host kernel can be exposed, so stronger isolation is required for untrusted tenants.
- Question 30Multiple Select
Which two statements are accurate about Docker security in multi-tenant environments when running GPU workloads?
- AContainers share the host kernelCorrect answer
- BVMs provide stronger isolationCorrect answer
- CContainers are hardware VMs
- DGPU memory is automatically encrypted
Why this is the answer
Containers share the host kernel, so isolation is weaker than VMs. Namespaces are useful but do not make containers equivalent to hardware virtual machines.
- Question 31Interactive
A command runs a GPU container with an elevated privileges flag. Why is this a security concern in a multi-tenant cluster?
- AIt grants broad host capabilitiesCorrect answer
- BIt prevents NVIDIA driver loading
- CIt forces CPU-only execution
- DIt exposes MIG to all tenants
Why this is the answer
The --privileged flag gives the container broad host capabilities, which weakens the isolation boundary and increases risk in multi-tenant clusters.
- Question 32Single Choice
In Kubernetes, what is the difference between scaling a GPU workload and scheduling the workload on a GPU node?
- AScheduling places pods; scaling changes replicas or nodesCorrect answer
- BScaling places pods; scheduling changes replicas
- CBoth terms describe the same process
- DScheduling installs the container runtime
Why this is the answer
Scheduling is the placement of pods on suitable nodes. Scaling is increasing or decreasing the number of replicas or nodes.
Workload Management
10 questions in this domain
- Question 33Single Choice
In a containerized GPU workload, where must the NVIDIA driver be installed for the container to access the GPU?
- AOn the host machineCorrect answer
- BInside the container image
- CIn the application code
- DIn the cluster network
Why this is the answer
The NVIDIA driver must be installed on the host OS; the NVIDIA Container Toolkit enables the container to use the host driver.
- Question 34Multiple Select
Which statements about the container image tag 'latest' are correct when managing production AI workloads?
- AIt can change over timeCorrect answer
- BIt is immutable
- CPinning a digest improves reproducibilityCorrect answer
- DIt is always the stable release
Why this is the answer
'latest' is a mutable tag that may move to newer builds. Pinning an image by digest or exact version provides stable, reproducible workloads.
- Question 35Interactive
Review the command in the code block. Where is the NVIDIA driver that supports this containerized GPU workload installed?
- AThe NVIDIA driverCorrect answer
- BThe CUDA application
- CThe container registry
- DThe overlay network
Why this is the answer
The command starts a CUDA container that calls nvidia-smi. The host must provide the NVIDIA driver; the container uses it through the container toolkit.
- Question 36Single Choice
What is a correct statement about Docker's security boundary in a shared multi-tenant AI environment?
- AContainers share the host kernelCorrect answer
- BContainers match hardware virtualization isolation
- CDocker removes kernel security risk
- DContainers each have their own kernel
Why this is the answer
Docker containers share the host OS kernel, so a kernel or daemon vulnerability can affect all tenants. This is a critical security boundary consideration.
- Question 37Multiple Select
Select the activities that are characteristic of scheduling rather than scaling in a GPU cluster.
- APlacing a job on a suitable GPUCorrect answer
- BAdding a node to the cluster
- CAssigning work to free GPUsCorrect answer
- DIncreasing replica count
Why this is the answer
Scheduling places individual workloads onto available resources. Scaling changes the total amount of resources or replicas by adding or removing nodes.
- Question 38Interactive
The command in the code block changes a deployment's replica count. Which workload management operation does it represent?
- AScalingCorrect answer
- BScheduling
- CCheckpointing
- DPreemption
Why this is the answer
Changing the replica count changes capacity, so it is scaling. Scheduling would decide where each replica runs under resource constraints.
- Question 39Single Choice
Why is checkpointing essential for deep learning workloads that may be preempted by a scheduler?
- AIt lets the workload resume from saved stateCorrect answer
- BIt increases GPU clock speed
- CIt prevents scheduler preemption
- DIt removes the need for model weights
Why this is the answer
Checkpointing periodically saves state so preempted workloads can restart from the last checkpoint, minimizing lost computation and allowing resumption.
- Question 40Multiple Select
Which statements about checkpointing in preemptible AI workloads are correct for preserving compute progress?
- ACheckpoints reduce lost workCorrect answer
- BFrequent checkpoints save progressCorrect answer
- CCheckpoints help update GPU drivers
- DCheckpoints schedule cluster jobs
Why this is the answer
Frequent checkpoints preserve model state and reduce the amount of work lost after preemption. They do not affect hardware behavior or scheduling decisions.
- Question 41Interactive
The code block persists the current model state. Why is this action important for preemptible workloads?
- AIt enables resuming from the saved stateCorrect answer
- BIt compresses the container image
- CIt forces a GPU scheduler to act
- DIt replaces the need for a driver
Why this is the answer
Saving model state allows a preempted job to resume from the checkpoint rather than starting over, preserving expensive GPU compute work.
- Question 42Single Choice
Why should a scheduler consider hardware topology when assigning multi-GPU workloads in a server?
- AGPU interconnects affect performanceCorrect answer
- BAll GPUs are always equal
- CMore GPUs always increase memory
- DTopology only affects display output
Why this is the answer
Hardware topology determines which GPUs are directly connected, for example through NVLink. Choosing nearby GPUs improves inter-GPU communication performance.
Frequently asked questions
Everything about the NVIDIA Certified Professional - AI Operations question bank and how to use it.