Intel Device Plugins Operator

The Intel Device Plugins Operator is the longest-established approach for exposing Intel GPUs to Kubernetes workloads. It is certified on OpenShift and available through the Red Hat Ecosystem Catalog.

Use this operator when you need a generally available, OpenShift-certified component or your existing workloads request GPUs as extended resources. For new deployments or workloads that select GPUs by device attributes, prefer the Intel GPU Resource Driver (DRA).

This procedure uses the traditional Kubernetes device plugin approach. The GPU device plugin runs as a DaemonSet on GPU-enabled nodes, registers GPU resources with the kubelet, and exposes the following resource names for workload requests.

Resource Name

Description

gpu.intel.com/xe

GPU resource for the xe driver.

gpu.intel.com/i915

GPU resource for the legacy i915 driver.

gpu.intel.com/monitoring

Resource that grants a telemetry workload access to every GPU on the node.

Note

The certified-operators catalog usually trails the upstream project by one release. At the time of validation the catalog shipped Intel Device Plugins Operator 0.36.0, while the upstream release was 0.37.0. Check oc get packagemanifest intel-device-plugins-operator -n openshift-marketplace to see which version your cluster offers. Use the catalog version on OpenShift, because it is the build that carries Red Hat certification.

Installing and verifying the Intel Device Plugins Operator

  1. Install the Intel Device Plugins Operator from the certified-operators catalog.

    apiVersion: operators.coreos.com/v1alpha1
    kind: Subscription
    metadata:
      name: intel-device-plugins-operator
      namespace: openshift-operators
    spec:
      channel: stable
      name: intel-device-plugins-operator
      source: certified-operators
      sourceNamespace: openshift-marketplace
      installPlanApproval: Automatic
    
  2. Verify that the operator is running.

    oc get csv -n openshift-operators | grep intel
    oc get pods -n openshift-operators | grep intel-deviceplugins-controller-manager
    
  3. Create a custom cluster-scoped GpuDevicePlugin resource, which does not require a namespace in the metadata.

    apiVersion: deviceplugin.intel.com/v1
    kind: GpuDevicePlugin
    metadata:
      name: intel-gpu-plugin
    spec:
      nodeSelector:
        intel.feature.node.kubernetes.io/gpu: "true"
      sharedDevNum: 1
      enableMonitoring: true
      monitoringMode: single
      logLevel: 2
    

    No SecurityContextConstraints changes are required. The operator ships the SCC that its DaemonSet needs and OLM grants it during installation.

    The following table summarizes the configuration options available in the deviceplugin.intel.com/v1 API:

    Field

    Default

    Description

    sharedDevNum

    1

    Defines how many containers can share a single GPU device. A value of 1 provides exclusive access.

    enableMonitoring

    false

    Exposes the gpu.intel.com/monitoring resource so a telemetry workload can access every GPU on the node.

    monitoringMode

    single

    Controls how the monitoring resource is published. single exposes one resource covering all GPUs; split exposes a separate resource per driver.

    logLevel

    4

    Sets the plugin logging verbosity, where higher values produce more detailed logs for troubleshooting.

    preferredAllocationPolicy

    none

    Controls how GPUs are assigned to workloads. Use balanced to spread allocations, packed to prefer consolidation, or none to use the default behavior. Only valid when sharedDevNum is greater than 1.

    bypathMode

    single

    Controls which DRM by-path symlinks are mounted into containers. Accepts single, all, or none.

    allowIDs

    “”

    Comma-separated list of PCI IDs. When set, only GPUs whose PCI ID matches are advertised. Cannot be combined with denyIDs.

    denyIDs

    “”

    Comma-separated list of PCI IDs to exclude from advertisement. Cannot be combined with allowIDs.

    nodeSelector

    {}

    Constrains the plugin DaemonSet to nodes carrying the given labels.

    tolerations

    []

    Tolerations that let the plugin run on tainted GPU nodes.

    Important

    Setting preferredAllocationPolicy while sharedDevNum is 1 is rejected by the operator’s validating webhook with invalid resource: 'balanced' PreferredAllocationPolicy is valid only when setting sharedDevNum > 1. Leave the field unset for exclusive GPU access.

  4. Verify that the plugin DaemonSet is running.

    oc get GpuDevicePlugin
    oc get pods -n openshift-operators -l app=intel-gpu-plugin
    

    The GpuDevicePlugin output reports the DaemonSet rollout and the node selector in use:

    NAME               DESIRED   READY   NODE SELECTOR                                     AGE
    intel-gpu-plugin   1         1       {"intel.feature.node.kubernetes.io/gpu":"true"}   61s
    
  5. Confirm that the node now advertises allocatable GPU resources. The count matches the number of physical GPUs multiplied by sharedDevNum.

    oc get node <gpu-node> -o jsonpath='{.status.allocatable}' | jq 'with_entries(select(.key|test("gpu.intel.com")))'
    

    For example, a node with eight Intel® Arc™ Pro B70 GPUs and sharedDevNum: 1 reports these allocatable resources:

    {
      "gpu.intel.com/monitoring": "1",
      "gpu.intel.com/xe": "8"
    }
    
  6. Run a test workload.

    apiVersion: v1
    kind: Pod
    metadata:
      name: intel-gpu-test
    spec:
      restartPolicy: Never
      containers:
      - name: gpu-test
        image: docker.io/intel/vllm:0.21.0-xpu
        args:
        - bash
        - -c
        - |
          ls -la /dev/dri/
          clinfo -l
          python -c "import torch; print('XPU available:', torch.xpu.is_available()); print('XPU devices:', torch.xpu.device_count())"
        resources:
          limits:
            gpu.intel.com/xe: 1
    

    Important

    Use args rather than command with the intel/vllm image. Its entrypoint sources /opt/intel/oneapi/setvars.sh before running the given command, and overriding command bypasses that step. The container then fails to import PyTorch with ImportError: libccl.so.1: cannot open shared object file.

  7. Verify that the test workload completed successfully and that the GPU was detected. A successful result includes output similar to the following, showing that exactly one GPU was injected into the container:

    card5
    renderD132
    Platform #1: Intel(R) OpenCL Graphics
     `-- Device #0: Intel(R) Graphics [0xe223]
    XPU available: True
    XPU devices: 1
    

After completing this procedure, OpenShift can advertise Intel GPU resources through the device plugin and schedule GPU-enabled workloads on labeled nodes.