Skip to content

Commit 1d747b3

Browse files
authored
feat(platform): auto-wire KubeVirt permittedHostDevices and HostDevices feature gate when gpu-operator is enabled (#2768)
Closes #2765. ## What this PR does Makes the passthrough and vGPU variants of `cozystack.gpu-operator` produce a KubeVirt CR that is immediately usable, without an out-of-band `kubectl patch`. Today the gpu-operator stack reports green, `nvidia.com/<model>` shows up under node `.status.allocatable`, but every `VirtualMachine` referencing the resource via `domain.devices.hostDevices` is rejected by the admission webhook because `HostDevices` is not in `developerConfiguration.featureGates` and the resource is not listed under `permittedHostDevices`. That manual reconciliation is now driven by the platform. The change has three parts. `packages/system/kubevirt` now parameterizes the KubeVirt CR template. `developerConfiguration.featureGates` keeps its existing static defaults and appends `.Values.extraFeatureGates`; `spec.configuration.permittedHostDevices` renders verbatim from `.Values.permittedHostDevices` when set; `spec.configuration.mediatedDevicesConfiguration` does the same. Defaults stay empty so the rendered CR is byte-identical to the previous template when no overrides are supplied. The chart's `make update` target re-applies the four sed transforms after fetching the upstream CR, so refreshing the KubeVirt release version stays a single command. `packages/core/platform` adds two defaults tables under `files/`. `gpu-passthrough-defaults.yaml` covers Hopper (H100/H200), Ada Lovelace (L4/L40/L40S), Ampere (A100 PCIe/SXM, A40, A30, A10), Turing (T4) and Volta (V100/V100S); PCI vendor:device pairs are stable, `resourceName` slugs follow the `<arch>_<model>_<form>_<mem>` convention `nvidia-sandbox-device-plugin` generates as of v25.x, and `externalResourceProvider: true` is set everywhere because those resources are advertised by the sandbox plugin rather than KubeVirt's in-tree device plugin. `gpu-vgpu-defaults.yaml` covers the Pascal–Ampere mdev profile range (A100-40C/80C, A40-24Q/48Q, A30-24C, A10-24Q, V100D-32C, T4-16Q) — the same family span the upstream `vgpu-device-manager` walks `/sys/class/mdev_bus/` for. Ada Lovelace and Blackwell SR-IOV vGPU is intentionally out of scope for the default table and is expected to be advertised via the user-override hook described below. `templates/bundles/iaas.yaml` now selects between the two tables via a new `bundles.iaas.gpuOperatorVariant` knob (`default` for passthrough, `vgpu` for mediated; default is passthrough). The same variant flows through to the gpu-operator Package CR, replacing the previous always-default call. When the package is enabled, the platform injects `HostDevices` into `extraFeatureGates` plus the chosen defaults into `permittedHostDevices` for the kubevirt component's values. Operators extend or replace via top-level platform values: ```yaml gpu: replaceDefaults: false # append (default) vs. wipe-and-replace permittedHostDevices: pciHostDevices: [] # cluster-specific PCI passthrough entries mediatedDevices: [] # cluster-specific vGPU entries mediatedDevicesConfiguration: {} # extra mediated-device types / per-node mappings ``` `docs/gpu-vgpu.md` is updated to drop the manual `kubectl patch` step and describe the auto-wiring contract, the per-variant defaults, the escape hatches, and the sandbox-device-plugin `resourceName` slug convention so an operator whose node publishes a different name knows where to override. ## Test coverage `helm-unittest` covers eight branches in `packages/core/platform/tests/bundles_gpu_kubevirt_wiring_test.yaml`: gpu-operator disabled emits no extras; gpu-operator enabled at default variant emits the HostDevices gate plus `pciHostDevices`; vgpu variant switches to `mediatedDevices` plus `mediatedDevicesConfiguration`; user overrides append by default; `replaceDefaults: true` wipes the platform table; an unknown variant fails fast with a descriptive error. `packages/system/kubevirt/tests/kubevirt_cr_test.yaml` pins the empty-values render and the three populated shapes at the CR template level. `make helm-unit-tests` passes locally on the full repo. ### Release note ```release-note feat(platform): the KubeVirt CR is now auto-configured for GPU host-device passthrough (HostDevices feature gate plus permittedHostDevices populated from NVIDIA defaults) whenever cozystack.gpu-operator is in bundles.enabledPackages. Operators no longer need a manual kubectl patch to make VMs schedule against a GPU. The variant is selected via bundles.iaas.gpuOperatorVariant (default: passthrough; vgpu: mediated). Extend or replace the NVIDIA defaults via .gpu.permittedHostDevices and .gpu.replaceDefaults. **Upgrade note:** the bundle now OWNS spec.configuration.permittedHostDevices on the KubeVirt CR. If you previously hand-edited it (kubectl edit kubevirt), the first reconcile after upgrade overwrites your manual entries with the rendered NVIDIA default table. Before upgrading, move any custom entries into .gpu.permittedHostDevices (set .gpu.replaceDefaults: true to keep only your list) and verify each resourceName against what your nodes advertise (kubectl describe node <node> | grep nvidia.com/) — the default table now carries the exact slug the sandbox device plugin generates, which upper-cases the card's PCI-IDs name and keeps the Tesla/GL tokens (e.g. a Tesla T4 is nvidia.com/TU104GL_TESLA_T4), but a different plugin build can publish a different string; a mismatch makes the admission webhook reject GPU VMs on their next restart or migration. ``` <!-- This is an auto-generated comment: release notes by coderabbit.ai --> ## Summary by CodeRabbit * **New Features** * Bundle-managed GPU Operator with selectable passthrough vs vGPU variants; platform now injects GPU settings into KubeVirt and forwards vGPU manager overrides when enabled. * Default platform mappings for PCI passthrough and vGPU mediated-device resources added. * **Documentation** * Expanded GPU/vGPU deployment guide with bundle-managed vs manual guidance, wiring/precedence rules, resource-name conventions, and verification steps. * **Tests** * New and expanded tests for bundle→KubeVirt wiring, variant behaviors, default/override merging, and idempotent template parameterization. * **Chores** * Added Helm test target and hardened KubeVirt template update/idempotency checks. <!-- end of auto-generated comment: release notes by coderabbit.ai -->
2 parents b610803 + 117d317 commit 1d747b3

11 files changed

Lines changed: 1451 additions & 38 deletions

File tree

‎docs/gpu-vgpu.md‎

Lines changed: 60 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -39,30 +39,30 @@ The proprietary `.run` is the **Linux KVM** variant (not the Ubuntu KVM `.deb`,
3939
4040
## Deploying with the vgpu variant
4141

42-
Create a `Package` CR pointing at your image coordinates:
42+
The platform's `iaas` bundle deploys the gpu-operator Package CR when `cozystack.gpu-operator` is in `bundles.enabledPackages` and `bundles.iaas.gpuOperatorVariant: vgpu` is set. The vGPU Manager image is proprietary and not redistributable, so the bundle does not ship a default tag — the operator builds the container per the upstream [`gpu-driver-container`](https://github.com/NVIDIA/gpu-driver-container) recipe and supplies the private-registry coordinates through platform values:
4343

4444
```yaml
45-
apiVersion: cozystack.io/v1alpha1
46-
kind: Package
47-
metadata:
48-
name: cozystack.gpu-operator
49-
spec:
50-
variant: vgpu
51-
components:
52-
gpu-operator:
53-
values:
54-
gpu-operator:
55-
vgpuManager:
56-
repository: registry.example.com/nvidia
57-
image: vgpu-manager
58-
version: "595.58.02-ubuntu24.04"
59-
# imagePullSecrets lives per-component (vgpuManager,
60-
# driver, validator, dcgmExporter, …). The value is a
61-
# list of strings, not [{name: ...}].
62-
imagePullSecrets:
63-
- nvidia-registry-secret
45+
bundles:
46+
iaas:
47+
enabled: true
48+
gpuOperatorVariant: vgpu
49+
enabledPackages:
50+
- cozystack.gpu-operator
51+
52+
gpu:
53+
vgpuManager:
54+
repository: registry.example.com/nvidia
55+
image: vgpu-manager
56+
version: "595.58.02-ubuntu24.04"
57+
# imagePullSecrets lives per-component (vgpuManager, driver,
58+
# validator, dcgmExporter, …). The value is a list of strings,
59+
# not [{name: ...}].
60+
imagePullSecrets:
61+
- nvidia-registry-secret
6462
```
6563
64+
The platform forwards `gpu.vgpuManager` into the emitted gpu-operator Package CR's `components.gpu-operator.values.gpu-operator.vgpuManager`, so the bundle handles the variant + image coordinates in one place. If you need to override anything else on the gpu-operator chart (driver, validator, dcgmExporter, custom node selectors), hand-craft a `Package` CR named `cozystack.gpu-operator` with the full `components.gpu-operator.values` block — that takes precedence over the bundle render.
65+
6666
The `nvidia-registry-secret` should be a docker-registry Secret created beforehand in `cozy-gpu-operator`.
6767

6868
Verify the DaemonSet is running and `nvidia.ko` loads on every GPU node:
@@ -95,24 +95,54 @@ For Pascal–Ampere GPUs (V100, T4, A100, A30) the mdev model still applies. Fli
9595

9696
## KubeVirt configuration
9797

98-
After [kubevirt#16890](https://github.com/kubevirt/kubevirt/pull/16890), `virt-handler` recognises SR-IOV VFs bound to the `nvidia` driver as candidates whenever a vGPU profile is configured (`current_vgpu_type` ≠ 0). PFs are skipped automatically.
98+
When `cozystack.gpu-operator` is in `bundles.enabledPackages` (and not also in `bundles.disabledPackages`), the platform mirrors the chosen GPU variant into the `KubeVirt` CR automatically. There is no manual `kubectl patch` step.
99+
100+
If you opt out of bundle management and hand-craft a `cozystack.gpu-operator` Package CR directly — typically to apply overrides the bundle does not expose (driver settings, custom node selectors, validator / dcgmExporter tweaks, etc.) — the platform does NOT auto-wire `HostDevices` or `permittedHostDevices` into the KubeVirt CR. In that flow you also hand-craft a `cozystack.kubevirt` Package CR with `components.kubevirt.values.extraFeatureGates: [HostDevices]` and the appropriate `permittedHostDevices` block. The escape-hatch values shape under `.gpu` (below) is intentionally documented in the bundle-managed flow only; the manual Package-CR override path takes precedence over the bundle render whenever both exist.
101+
102+
- `developerConfiguration.featureGates` gets `HostDevices` appended (current KubeVirt splits this from the `GPU` gate; the admission webhook rejects `spec.template.spec.domain.devices.hostDevices` without it).
103+
- `permittedHostDevices.pciHostDevices` is filled from `packages/core/platform/files/gpu-passthrough-defaults.yaml` when `bundles.iaas.gpuOperatorVariant: default` (the package default). The table covers Hopper (H100/H200), Ada Lovelace (L4/L40/L40S), Ampere (A100 PCIe/SXM, A40, A30, A10), Turing (T4), Volta (V100/V100S). All entries carry `externalResourceProvider: true` because the resource names come from `nvidia-sandbox-device-plugin`, not from KubeVirt's in-tree device plugin.
104+
- `permittedHostDevices.mediatedDevices` is filled from `packages/core/platform/files/gpu-vgpu-defaults.yaml` when `bundles.iaas.gpuOperatorVariant: vgpu`. This list only EXPOSES, by profile name (`mdevNameSelector`), mdevs that the GPU Operator's vGPU Device Manager CREATES on the node; the platform does not ship a numeric `mediatedDevicesConfiguration` default (those `nvidia-NNN` type ids are per-SKU/driver sysfs indices with no portable value — set `.gpu.mediatedDevicesConfiguration` yourself, with host-verified ids, only if you want KubeVirt rather than the Device Manager to create mdevs). The starter set covers Pascal–Ampere mdev profiles (A100-40C/80C, A40-24Q/48Q, A30-24C, A10-24Q, V100D-32C, T4-16Q) — the same family range as the upstream `vgpu-device-manager` walks `/sys/class/mdev_bus/` for. Ada Lovelace / Blackwell SR-IOV vGPU is out of scope for the chart's default list; advertise those VFs via the user-override hook below.
105+
106+
### Extending or replacing the default table
99107

100-
Patch the `KubeVirt` CR to permit the resource:
108+
The platform exposes three knobs under `.gpu`:
101109

102110
```yaml
103-
spec:
104-
configuration:
105-
permittedHostDevices:
106-
pciHostDevices:
107-
- pciVendorSelector: "10DE:26B9" # L40S — same device ID for PF and VF
108-
resourceName: nvidia.com/L40S-24Q
111+
gpu:
112+
# Extend the platform defaults with cluster-specific entries. Both list
113+
# keys are read in both variants: pciHostDevices feeds the passthrough
114+
# (vfio-pci) path AND the post-kubevirt#16890 SR-IOV vGPU VF path on
115+
# Ada Lovelace / Blackwell; mediatedDevices feeds the pre-#16890 mdev
116+
# path on Pascal–Ampere. Both render into the same KubeVirt CR.
117+
permittedHostDevices:
118+
pciHostDevices:
119+
- pciVendorSelector: "10DE:26B9" # L40S, advertised as a VF for SR-IOV vGPU
120+
resourceName: nvidia.com/L40S-24Q
121+
# externalResourceProvider is intentionally omitted here: after
122+
# kubevirt/kubevirt#16890, virt-handler's in-tree device plugin
123+
# advertises the resource directly, no sandbox plugin in the loop.
124+
mediatedDevices: []
125+
# mediatedDevicesConfiguration makes KubeVirt itself create mdevs (vgpu mode). No platform default: mdev creation is normally delegated to the vGPU Device Manager (name-based), and these mediatedDeviceTypes are host/driver-specific nvidia-NNN sysfs indices (look yours up via /sys/bus/pci/devices/<BDF>/mdev_supported_types/*/name). Set this only to opt into KubeVirt-driven creation; mergeOverwrite REPLACES a supplied top-level key wholesale.
126+
mediatedDevicesConfiguration: {}
127+
# Wipe the platform defaults entirely and ship only the cluster's
128+
# curated lists. Useful for non-NVIDIA-only clusters and strict
129+
# allowlist requirements.
130+
replaceDefaults: false
109131
```
110132

133+
`replaceDefaults: false` (the default) appends user entries to the NVIDIA defaults. `replaceDefaults: true` drops the NVIDIA table entirely — if you don't then supply your own pciHostDevices / mediatedDevices list, the rendered KubeVirt CR has no `permittedHostDevices` block and the admission webhook will reject every GPU VM.
134+
135+
### Notes on `nvidia-sandbox-device-plugin` resource names
136+
137+
The `resourceName` strings in `gpu-passthrough-defaults.yaml` are what `nvidia-sandbox-device-plugin` (`nvcr.io/nvidia/kubevirt-gpu-device-plugin`) advertises: it derives each slug mechanically from the device's PCI-IDs database name by uppercasing it, turning `/`, `.` and whitespace into `_`, and stripping the remaining non-alphanumerics (the `[` / `]`). So `TU104GL [Tesla T4]` becomes `nvidia.com/TU104GL_TESLA_T4` and `GA100GL [A30 PCIe]` becomes `nvidia.com/GA100GL_A30_PCIE` — the slug carries every token the PCI-IDs string holds (the `GL` die suffix, the `Tesla` brand on Turing/Volta, form factor, memory), not a tidy `<arch>_<model>`. The names track the pci.ids snapshot bundled in the plugin image, so a different plugin build can publish a different string — check with `kubectl describe node <node> | grep nvidia.com/` and override via `.gpu.permittedHostDevices.pciHostDevices` (or wipe the table with `replaceDefaults: true` and curate it yourself). PCI vendor:device IDs themselves are stable across driver versions.
138+
139+
### SR-IOV PF vs VF (Ada Lovelace and newer)
140+
111141
On L40S (and other Ada-Lovelace cards) the SR-IOV VFs report the same PCI device ID as the PF — `lspci -nn -d 10de:` on the host shows both as `[10de:26b9]`. `virt-handler` distinguishes them by `is-VF + has-vGPU-profile`, so a single `pciVendorSelector` matches the right set. Verify on your specific GPU before assuming this — some other generations split PF/VF IDs.
112142

113-
`externalResourceProvider: true` is **not** required here (and should be omitted) — the device plugin lives inside `virt-handler` itself, no external sandbox-device-plugin advertises this resource.
143+
`externalResourceProvider: true` is **not** required when the resource is advertised by `virt-handler`'s in-tree device plugin (the SR-IOV path post kubevirt#16890). The platform passthrough defaults include the flag because that path is driven by the external sandbox plugin.
114144

115-
Verify allocatable capacity:
145+
### Verifying allocatable capacity
116146

117147
```bash
118148
kubectl get nodes -o jsonpath='{range .items[*]}{.metadata.name}{": "}{.status.allocatable.nvidia\.com/L40S-24Q}{"\n"}{end}'
Lines changed: 89 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,89 @@
1+
# NVIDIA datacenter GPUs commonly used in passthrough VFIO mode. Used by
2+
# bundles/iaas.yaml when bundles.iaas.gpuOperatorVariant=default and
3+
# cozystack.gpu-operator is in bundles.enabledPackages. Auto-injected into
4+
# the KubeVirt CR at spec.configuration.permittedHostDevices.pciHostDevices.
5+
#
6+
# PCI vendor:device pairs are stable vendor-assigned identifiers under the
7+
# PCI-SIG-administered namespace and do not drift across driver versions.
8+
#
9+
# The resourceName is what nvidia-sandbox-device-plugin
10+
# (nvcr.io/nvidia/kubevirt-gpu-device-plugin, the image shipped by the
11+
# gpu-operator package) advertises on the node. The plugin derives it
12+
# mechanically from the device's PCI-IDs database name: uppercase the
13+
# name, turn "/", "." and whitespace into "_", then strip the remaining
14+
# non-alphanumerics (the "[" / "]" around the model). So
15+
# "TU104GL [Tesla T4]" becomes nvidia.com/TU104GL_TESLA_T4 and
16+
# "GA100GL [A30 PCIe]" becomes nvidia.com/GA100GL_A30_PCIE — the slug
17+
# carries every token the PCI-IDs string holds (die suffix "GL", the
18+
# "Tesla" brand on Turing/Volta, form factor, memory), not a tidy
19+
# <arch>_<model>. The names here track the pci.ids snapshot bundled in
20+
# the plugin image; a different plugin build can emit a different string.
21+
# Always confirm against the live node (kubectl describe node <node> |
22+
# grep nvidia.com/) and extend or replace via .Values.gpu.permittedHostDevices
23+
# / .Values.gpu.replaceDefaults when it differs.
24+
#
25+
# externalResourceProvider: true is mandatory here — the resource is
26+
# published by the sandbox-device-plugin DaemonSet, not by KubeVirt itself.
27+
pciHostDevices:
28+
# Hopper
29+
- pciVendorSelector: "10DE:2335"
30+
resourceName: nvidia.com/GH100_H200_SXM_141GB
31+
externalResourceProvider: true
32+
- pciVendorSelector: "10DE:2330"
33+
resourceName: nvidia.com/GH100_H100_SXM5_80GB
34+
externalResourceProvider: true
35+
- pciVendorSelector: "10DE:2331"
36+
resourceName: nvidia.com/GH100_H100_PCIE
37+
externalResourceProvider: true
38+
- pciVendorSelector: "10DE:2321"
39+
resourceName: nvidia.com/GH100_H100L_94GB
40+
externalResourceProvider: true
41+
# Ada Lovelace (datacenter SKUs)
42+
- pciVendorSelector: "10DE:26B9"
43+
resourceName: nvidia.com/AD102GL_L40S
44+
externalResourceProvider: true
45+
- pciVendorSelector: "10DE:26B5"
46+
resourceName: nvidia.com/AD102GL_L40
47+
externalResourceProvider: true
48+
- pciVendorSelector: "10DE:27B8"
49+
resourceName: nvidia.com/AD104GL_L4
50+
externalResourceProvider: true
51+
# Ampere
52+
- pciVendorSelector: "10DE:20B2"
53+
resourceName: nvidia.com/GA100_A100_SXM4_80GB
54+
externalResourceProvider: true
55+
- pciVendorSelector: "10DE:20B0"
56+
resourceName: nvidia.com/GA100_A100_SXM4_40GB
57+
externalResourceProvider: true
58+
- pciVendorSelector: "10DE:20B5"
59+
resourceName: nvidia.com/GA100_A100_PCIE_80GB
60+
externalResourceProvider: true
61+
- pciVendorSelector: "10DE:20F1"
62+
resourceName: nvidia.com/GA100_A100_PCIE_40GB
63+
externalResourceProvider: true
64+
- pciVendorSelector: "10DE:20B7"
65+
resourceName: nvidia.com/GA100GL_A30_PCIE
66+
externalResourceProvider: true
67+
- pciVendorSelector: "10DE:2235"
68+
resourceName: nvidia.com/GA102GL_A40
69+
externalResourceProvider: true
70+
- pciVendorSelector: "10DE:2236"
71+
resourceName: nvidia.com/GA102GL_A10
72+
externalResourceProvider: true
73+
# Turing
74+
- pciVendorSelector: "10DE:1EB8"
75+
resourceName: nvidia.com/TU104GL_TESLA_T4
76+
externalResourceProvider: true
77+
# Volta
78+
- pciVendorSelector: "10DE:1DB1"
79+
resourceName: nvidia.com/GV100GL_TESLA_V100_SXM2_16GB
80+
externalResourceProvider: true
81+
- pciVendorSelector: "10DE:1DB5"
82+
resourceName: nvidia.com/GV100GL_TESLA_V100_SXM2_32GB
83+
externalResourceProvider: true
84+
- pciVendorSelector: "10DE:1DB4"
85+
resourceName: nvidia.com/GV100GL_TESLA_V100_PCIE_16GB
86+
externalResourceProvider: true
87+
- pciVendorSelector: "10DE:1DF6"
88+
resourceName: nvidia.com/GV100GL_TESLA_V100S_PCIE_32GB
89+
externalResourceProvider: true
Lines changed: 58 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,58 @@
1+
# NVIDIA vGPU profiles to EXPOSE to VMs in vGPU mode. Used by
2+
# bundles/iaas.yaml when bundles.iaas.gpuOperatorVariant=vgpu and
3+
# cozystack.gpu-operator is in bundles.enabledPackages. Auto-injected
4+
# into the KubeVirt CR at spec.configuration.permittedHostDevices.mediatedDevices.
5+
#
6+
# Division of labour: the GPU Operator's vGPU Device Manager CREATES the
7+
# mdev devices on each node from a name-based profile config; KubeVirt
8+
# only EXPOSES the already-created mdevs to VMs, matched by profile name
9+
# via mdevNameSelector. This file therefore carries only the name-based
10+
# exposure list — it does NOT ship a mediatedDevicesConfiguration block.
11+
# That block's mediatedDeviceTypes are numeric nvidia-NNN ids that make
12+
# KubeVirt itself create mdevs, but those ids are per-(SKU, driver) sysfs
13+
# indices with no portable value, and would duplicate the Device
14+
# Manager. Operators who deliberately want KubeVirt to drive creation set
15+
# host-verified ids via .Values.gpu.mediatedDevicesConfiguration instead.
16+
#
17+
# mdevNameSelector must match the on-host profile name the driver exposes
18+
# under /sys/bus/pci/devices/<BDF>/mdev_supported_types/*/name — which is
19+
# driver-branch-dependent ("NVIDIA A100-40C" on the vGPU 13+/AIE branch,
20+
# "GRID A100-40C" on older GRID drivers). The profiles below cover the
21+
# 24Q/48Q and whole-card C splits on the families cozystack supports for
22+
# vGPU (Ampere and earlier — Ada Lovelace and Blackwell use per-VF NVIDIA
23+
# sysfs and are out of scope; see system/gpu-operator/values-vgpu.yaml).
24+
# Verify against the live node and override via
25+
# .Values.gpu.permittedHostDevices / .Values.gpu.replaceDefaults if your
26+
# driver exposes different names:
27+
#
28+
# for t in /sys/bus/pci/devices/<BDF>/mdev_supported_types/*; do \
29+
# echo "$(basename "$t") -> $(cat "$t"/name)"; done
30+
#
31+
# externalResourceProvider: true is mandatory — the mediated devices are
32+
# published by the vGPU Manager DaemonSet, not by KubeVirt itself.
33+
permittedHostDevices:
34+
mediatedDevices:
35+
- mdevNameSelector: NVIDIA A100-40C
36+
resourceName: nvidia.com/A100-40C
37+
externalResourceProvider: true
38+
- mdevNameSelector: NVIDIA A100-80C
39+
resourceName: nvidia.com/A100-80C
40+
externalResourceProvider: true
41+
- mdevNameSelector: NVIDIA A40-48Q
42+
resourceName: nvidia.com/A40-48Q
43+
externalResourceProvider: true
44+
- mdevNameSelector: NVIDIA A40-24Q
45+
resourceName: nvidia.com/A40-24Q
46+
externalResourceProvider: true
47+
- mdevNameSelector: NVIDIA A30-24C
48+
resourceName: nvidia.com/A30-24C
49+
externalResourceProvider: true
50+
- mdevNameSelector: NVIDIA A10-24Q
51+
resourceName: nvidia.com/A10-24Q
52+
externalResourceProvider: true
53+
- mdevNameSelector: NVIDIA V100D-32C
54+
resourceName: nvidia.com/V100D-32C
55+
externalResourceProvider: true
56+
- mdevNameSelector: NVIDIA T4-16Q
57+
resourceName: nvidia.com/T4-16Q
58+
externalResourceProvider: true

0 commit comments

Comments
 (0)