### Install Build Dependencies and Build DPDK

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/dlb_plugin/README.md

Installs necessary build tools and libraries for DPDK on Ubuntu/Debian systems, then configures and builds DPDK. Ensure you are in the dpdk-* directory before running meson setup.

```bash
sudo apt-get update && sudo apt-get install build-essential meson python3-pyelftools libnuma-dev python3-pip && sudo pip install ninja
cd ./dpdk-* && meson setup --prefix $(pwd)/installdir builddir && ninja -C builddir install
```

--------------------------------

### Install and Use setup-envtest

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/DEVEL.md

Installs the setup-envtest tool and demonstrates its usage for setting up the environment for controller integration testing with a local control plane.

```bash
$ go install sigs.k8s.io/controller-runtime/tools/setup-envtest@release-0.23
$ setup-envtest use <K8S_VERSION>
$ KUBEBUILDER_ASSETS=$(setup-envtest use -i -p path <K8S_VERSION>) make envtest
```

--------------------------------

### Compile and Run libdlb Example

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/dlb_plugin/README.md

Compile and execute a libdlb example application to verify the functionality of the configured DLB devices. Ensure LD_LIBRARY_PATH is set correctly.

```bash
$ cd ./dlb/libdlb/ && make && sudo LD_LIBRARY_PATH=$PWD ./examples/dir_traffic -n 128 -d 1

```

--------------------------------

### Example Node Label Output

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/OPENSHIFT.md

Example output showing the labels applied to a node after successful configuration.

```text
intel.feature.node.kubernetes.io/gpu=true
intel.feature.node.kubernetes.io/qat=true
intel.feature.node.kubernetes.io/sgx=true
intel.feature.node.kubernetes.io/dsa=true
```

--------------------------------

### Example: List Operator Chart Versions (including development)

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/INSTALL.md

Example output of searching for available versions of the intel/intel-device-plugins-operator Helm chart, including development versions.

```bash
$ helm search repo intel/intel-device-plugins-operator --versions --devel
NAME                               	CHART VERSION	APP VERSION	DESCRIPTION
intel/intel-device-plugins-operator	0.26.0       	0.26.0     	A Helm chart for Intel Device Plugins Operator ...
intel/intel-device-plugins-operator	0.25.1       	0.25.1     	A Helm chart for Intel Device Plugins Operator ...
intel/intel-device-plugins-operator	0.25.1-helm.0	0.25.0     	A Helm chart for Intel Device Plugins Operator ...
intel/intel-device-plugins-operator	0.25.0       	0.25.0     	A Helm chart for Intel Device Plugins Operator ...
intel/intel-device-plugins-operator	0.24.1       	0.24.1     	A Helm chart for Intel Device Plugins Operator ...
intel/intel-device-plugins-operator	0.24.1-helm.0	0.24.0     	A Helm chart for Intel Device Plugins Operator ...
intel/intel-device-plugins-operator	0.24.0       	0.24.0     	A Helm chart for Intel Device Plugins Operator ...
```

--------------------------------

### Example GpuDevicePlugin Output

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/OPENSHIFT.md

This is an example of the output you might see when querying for GpuDevicePlugin resources.

```text
NAME                     DESIRED   READY   NODE SELECTOR                                       AGE
gpudeviceplugin-sample   1         1       {"intel.feature.node.kubernetes.io/gpu":"true"}      3m
```

--------------------------------

### QAT Plugin Helm Chart Values Example

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/INSTALL.md

Example of values for the QAT plugin chart, showing configuration options for image, drivers, device limits, and node selectors.

```yaml
name: qatdeviceplugin-sample

image:
  hub: intel
  tag: ""

initImage:
  hub: intel
  tag: ""

dpdkDriver: vfio-pci
kernelVfDrivers:
  - 4xxxvf
  - 420xxvf
maxNumDevices: 128
logLevel: 4

nodeSelector:
  intel.feature.node.kubernetes.io/qat: 'true'

nodeFeatureRule: true
```

--------------------------------

### Install Specific Device Plugins

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/INSTALL.md

Install a specific device plugin by replacing PLUGIN with the desired plugin name (e.g., gpu, sgx, qat). The 'nodeFeatureRule' is set to true.

```bash
helm install <PLUGIN> intel/intel-device-plugins-<PLUGIN> --namespace inteldeviceplugins-system --create-namespace \
  --set nodeFeatureRule=true
```

--------------------------------

### Node Description Output Example

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/sgx_plugin/README.md

Example output from `kubectl describe node` showing SGX resource allocations. This helps verify the plugin's detection of SGX capabilities.

```text
                   nfd.node.kubernetes.io/extended-resources: sgx.intel.com/epc
 sgx.intel.com/enclave:    20
 sgx.intel.com/epc:        98566144
 sgx.intel.com/provision:  20
 sgx.intel.com/enclave:    20
 sgx.intel.com/epc:        98566144
 sgx.intel.com/provision:  20
 sgx.intel.com/enclave    0           0
 sgx.intel.com/epc        0           0
 sgx.intel.com/provision  0           0
```

--------------------------------

### Install Device Plugin Operator

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/INSTALL.md

Install the Intel Device Plugins Operator Helm chart into the 'inteldeviceplugins-system' namespace.

```bash
helm install dp-operator intel/intel-device-plugins-operator --namespace inteldeviceplugins-system --create-namespace
```

--------------------------------

### Install CDI Specs Generator Tool

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/gpu_plugin/cdi.md

Installs the `cdi-specs-generator` tool using `go install`. This tool is used to automatically create CDI specifications for detected Intel GPU devices.

```bash
go install github.com/intel/intel-resource-drivers-for-kubernetes/cmd/cdi-specs-generator@gpu-v0.8.0

```

--------------------------------

### Install Node Feature Discovery (NFD)

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/INSTALL.md

Install the NFD Helm chart to the 'node-feature-discovery' namespace.

```bash
helm install nfd nfd/node-feature-discovery \
  --namespace node-feature-discovery --create-namespace --version 0.16.4
```

--------------------------------

### Example Operator Pod Status

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/OPENSHIFT.md

Example output showing the running status of the Intel Device Plugins Operator controller manager pod.

```default
inteldeviceplugins-controller-manager-6b8c76c867-hftqm   1/1     Running   0   17m
```

--------------------------------

### Instantiate and Run Device Plugin Manager

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/DEVEL.md

Shows how to instantiate a deviceplugin.Manager and start its operation. The manager handles gRPC servers for device namespaces and coordinates device scanning.

```go
func main() {
    ...

    manager := dpapi.NewManager(namespace, plugin)
    manager.Run()
}
```

--------------------------------

### Install cert-manager

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/INSTALL.md

Install the cert-manager Helm chart, ensuring CRDs are installed. Note that this installation can take a significant amount of time.

```bash
helm install --wait \
  cert-manager jetstack/cert-manager \
  --namespace cert-manager \
  --create-namespace \
  --version v1.15.2 \
  --set installCRDs=true
```

--------------------------------

### CDI Specification Example

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/npu_plugin/README.md

A sample YAML configuration for defining an Intel NPU device using the Container Device Interface.

```yaml
---
cdiVersion: 0.5.0
kind: intel.com/npu
devices:
    - name: npu0
      containerEdits:
        deviceNodes:
            - path: /dev/accel/accel0
              hostPath: /dev/accel/accel0
              type: c
```

--------------------------------

### Install NFD and SGX Plugin using kubectl

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/sgx_plugin/README.md

Deploy NFD, NodeFeatureRules, and the SGX plugin using kubectl apply with kustomizations. Replace `<RELEASE_VERSION>` as needed.

```bash
# first, deploy NFD and the necessary NodeFeatureRules
kubectl apply -k 'https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/nfd'
kubectl apply -k 'https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/nfd/overlays/node-feature-rules'
# and then, deploy SGX plugin
kubectl apply -k 'https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/sgx_plugin/overlays/epc-nfd/'
```

--------------------------------

### Install Intel GPU plugin via NFD with monitoring

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/gpu_plugin/advanced-install.md

Deploys the plugin using NFD labels for node selection, including monitoring and shared device configurations. Ensure NFD is installed before applying these manifests.

```bash
# Start NFD - if your cluster doesn't have NFD installed yet
$ kubectl apply -k 'https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/nfd?ref=<RELEASE_VERSION>'

# Create NodeFeatureRules for detecting GPUs on nodes
$ kubectl apply -k 'https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/nfd/overlays/node-feature-rules?ref=<RELEASE_VERSION>'

# Create GPU plugin daemonset
$ kubectl apply -k 'https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/gpu_plugin/overlays/monitoring_shared-dev_nfd/?ref=<RELEASE_VERSION>'
```

--------------------------------

### Run vainfo with render-device.sh (Append Device)

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/gpu_plugin/README.md

Example of using the render-device.sh script to dynamically find the correct render device and pass it as an argument to vainfo. This is useful for VA-API applications.

```bash
command: ["render-device.sh", "vainfo", "--display", "drm", "--device"]

=> /usr/bin/vainfo --display drm --device /dev/dri/renderDXXX
```

--------------------------------

### Verify GPU Plugin Installation

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/gpu_plugin/README.md

Check the resource allocation status for Intel GPUs on nodes after installation. This command retrieves the node name and the number of allocatable i915 GPUs.

```bash
$ kubectl get nodes -o=jsonpath="{range .items[*]}{.metadata.name}{\'\n\'}{' i915: '}{.status.allocatable.gpu\.intel\.com/i915}{\'\n\'}"
master
 i915: 1
```

--------------------------------

### Device Plugin Scanner Implementation

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/DEVEL.md

Example implementation of the deviceplugin.Scanner interface. The Scan method continuously scans for devices, adds them to a DeviceTree, and notifies the manager.

```go
func (dp *devicePlugin) Scan(notifier deviceplugin.Notifier) error {
    for {
        devTree := deviceplugin.NewDeviceTree()
        ...
        devTree.AddDevice("yellow", devID, deviceplugin.DeviceInfo{
            State: health,
            Nodes: []pluginapi.DeviceSpec{
                {
                    HostPath:      devPath,
                    ContainerPath: devPath,
                    Permissions:   "rw",
                },
            },
        })
        ...
        notifier.Notify(devTree)
    }
}
```

--------------------------------

### Run Operator SDK OLM Install

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/DEVEL.md

Installs the Operator Lifecycle Manager (OLM) in the development cluster. This is a prerequisite for running and testing operator bundles.

```bash
operator-sdk olm install
```

--------------------------------

### GPU Plugin Resource Request (xe)

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/README.md

Example of a Pod specification requesting GPU xe resources.

```yaml
apiVersion: "v1"
kind: Pod
metadata:
  name: intelgpu-xe-sample-pod
spec:
  containers:
    - name: gpu-container
      image: <registry>/<image>:<version>
      resources:
        limits:
          gpu.intel.com/xe: 1
```

--------------------------------

### GPU Plugin Resource Request (i915)

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/README.md

Example of a Pod specification requesting GPU i915 resources.

```yaml
apiVersion: "v1"
kind: Pod
metadata:
  name: intelgpu-sample-pod
spec:
  containers:
    - name: gpu-container
      image: <registry>/<image>:<version>
      resources:
        limits:
          gpu.intel.com/i915: 1
```

--------------------------------

### Run vainfo with render-device.sh (Inline)

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/gpu_plugin/README.md

Example of using the render-device.sh script to find the render device and use it inline with the vainfo command via a shell variable. This is useful for VA-API applications.

```bash
command: ["/bin/sh", "-c",
          "vainfo --device $(render-device.sh 1) --display drm"
         ]
```

--------------------------------

### Deploy GpuDevicePlugin Custom Resource

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/operator/README.md

Applies a sample custom resource to deploy the GPU device plugin. This is an example; other device types (QAT, DSA, etc.) can be deployed similarly using their respective sample CRs.

```bash
$ kubectl apply -f https://raw.githubusercontent.com/intel/intel-device-plugins-for-kubernetes/main/deployments/operator/samples/deviceplugin_v1_gpudeviceplugin.yaml
```

--------------------------------

### GPU Plugin Resource Request (monitoring)

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/README.md

Example of a Pod specification requesting GPU monitoring resources.

```yaml
apiVersion: "v1"
kind: Pod
metadata:
  name: intelgpu-monitoring-sample-pod
spec:
  containers:
    - name: gpu-container
      image: <registry>/<image>:<version>
      resources:
        limits:
          gpu.intel.com/monitoring: 1
```

--------------------------------

### Deploy DSA Initcontainer for Automatic Provisioning

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/dsa_plugin/README.md

Deploy the included idxd initcontainer to automatically provision DSA devices and workqueues. This setup configures 1 engine, 1 group, and 1 wq (user/dedicated).

```bash
$ kubectl apply -k deployments/dsa_plugin/overlays/dsa_initcontainer/

```

--------------------------------

### Run Multiple Commands with render-device.sh

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/gpu_plugin/README.md

Example of using the render-device.sh script to find a render device and store it in a shell variable for use in multiple subsequent commands. This is useful for VA-API or QSV applications.

```bash
command: ["/bin/sh", "-c",
          "dev=$(render-device.sh 1) && vainfo --device $dev && <more commands>"
         ]
```

--------------------------------

### Install Intel GPU plugin to all nodes

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/gpu_plugin/advanced-install.md

Deploys the GPU plugin to every node in the cluster regardless of hardware presence. Replace <RELEASE_VERSION> with the desired version tag.

```bash
$ kubectl apply -k 'https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/gpu_plugin?ref=<RELEASE_VERSION>'
```

--------------------------------

### Example of /dev/dri/by-path Symlinks

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/gpu_plugin/README.md

Illustrates the symlinks created under /dev/dri/by-path for Intel GPU character devices. These symlinks provide device PCI addresses.

```text
$ ls -l /dev/dri/by-path/
lrwxrwxrwx 1 root root   8 oct   x 13:09 pci-0000:00:02.0-card -> ../card1
lrwxrwxrwx 1 root root  13 oct   x 13:09 pci-0000:00:02.0-render -> ../renderD128
```

--------------------------------

### Deploy accel-config test pod

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/dsa_plugin/README.md

Applies the YAML configuration to start the DSA accel-config demo pod.

```bash
$ kubectl apply -f ${INTEL_DEVICE_PLUGINS_SRC}/demo/dsa-accel-config-demo-pod.yaml
pod/dsa-accel-config-demo created
```

--------------------------------

### QAT Plugin Resource Request (CY)

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/README.md

Example of a Pod specification requesting QAT CY resources for cryptography.

```yaml
apiVersion: "v1"
kind: Pod
metadata:
  name: qat-cy-sample-pod
spec:
  containers:
    - name: qat-container
      image: <registry>/<image>:<version>
      resources:
        limits:
          qat.intel.com/cy: 1
```

--------------------------------

### Configure kind for SGX aesmd Host Mount

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/sgx_plugin/README.md

Example configuration for kind to mount the aesmd host path to nodes, required for quick experiments.

```yaml
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
name: <your_node_name>
nodes:
- role: control-plane
  extraMounts:
  - hostPath: /var/run/aesmd
    containerPath: /var/run/aesmd
    propagation: Bidirectional
```

--------------------------------

### Run Container with CDI Device

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/npu_plugin/README.md

Example of using the --device flag with a CDI device name to expose an NPU to a container.

```bash
$ docker run --device intel.com/npu=npu0 --rm -it ubuntu:24.04
```

--------------------------------

### QAT Plugin Resource Request (DC)

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/README.md

Example of a Pod specification requesting QAT DC resources for compression.

```yaml
apiVersion: "v1"
kind: Pod
metadata:
  name: qat-dc-sample-pod
spec:
  containers:
    - name: qat-container
      image: <registry>/<image>:<version>
      resources:
        limits:
          qat.intel.com/dc: 1
```

--------------------------------

### Install NFD and GPU Plugin with NFD

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/gpu_plugin/README.md

Deploy the Node Feature Discovery (NFD) and the Intel GPU plugin using NFD for node labeling. Replace <RELEASE_VERSION> with the desired release tag or 'main'.

```bash
# Start NFD - if your cluster doesn't have NFD installed yet
$ kubectl apply -k 'https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/nfd?ref=<RELEASE_VERSION>'

# Create NodeFeatureRules for detecting GPUs on nodes
$ kubectl apply -k 'https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/nfd/overlays/node-feature-rules?ref=<RELEASE_VERSION>'

# Create GPU plugin daemonset
$ kubectl apply -k 'https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/gpu_plugin/overlays/nfd_labeled_nodes?ref=<RELEASE_VERSION>'
```

--------------------------------

### FPGA Plugin Resource Request

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/README.md

Example of a Pod specification requesting FPGA resources. Refer to the FPGA mappings for specific resource names.

```yaml
apiVersion: "v1"
kind: Pod
metadata:
  name: intelfpga-sample-pod
spec:
  containers:
    - name: fpga-container
      image: <registry>/<image>:<version>
      resources:
        limits:
          fpga.intel.com/custom: 1
```

--------------------------------

### Build and Prepare Demo Image

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/npu_plugin/README.md

Commands to build the demo image and prepare it for cluster deployment.

```bash
$ make intel-npu-demo
```

```bash
$ docker tag intel/intel-npu-demo:devel <repository>/intel/intel-npu-demo:latest
$ docker push <repository>/intel/intel-npu-demo:latest
$ $EDITOR ${INTEL_DEVICE_PLUGINS_SRC}/demo/intel-npu-workload.yaml
```

```bash
$ docker save intel/intel-npu-demo:devel | ctr -n k8s.io images import -
```

--------------------------------

### Get Available E2E Test Options

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/DEVEL.md

Displays the full list of available command-line options for the end-to-end tests. This is helpful for understanding test configurations and arguments.

```bash
go test ./test/e2e/... -args -help
```

--------------------------------

### Deploy QAT Plugin with Initcontainer

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/qat_plugin/README.md

Deploys the QAT plugin using Kustomize to enable QAT SR-IOV VFs.

```bash
$ kubectl apply -k deployments/qat_plugin/overlays/qat_initcontainer/
```

--------------------------------

### Install Intel NPU Plugin with NFD

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/npu_plugin/README.md

Deploys the NPU plugin using Node Feature Discovery to identify nodes with Intel NPU hardware. Replace <RELEASE_VERSION> with the specific tag or 'main'.

```bash
# Start NFD - if your cluster doesn't have NFD installed yet
$ kubectl apply -k 'https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/nfd?ref=<RELEASE_VERSION>'

# Create NodeFeatureRules for detecting NPUs on nodes
$ kubectl apply -k 'https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/nfd/overlays/node-feature-rules?ref=<RELEASE_VERSION>'

# Create NPU plugin daemonset
$ kubectl apply -k 'https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/npu_plugin/overlays/nfd_labeled_nodes?ref=<RELEASE_VERSION>'
```

--------------------------------

### Deploy NFD and Node Feature Rules

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/operator/README.md

Installs Node Feature Discovery (NFD) and its associated node labelling rules. Ensure NFD is version 0.13 or higher. Replace `<RELEASE_VERSION>` with the appropriate tag.

```bash
# deploy NFD
$ kubectl apply -k 'https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/nfd?ref=<RELEASE_VERSION>'
# deploy NodeFeatureRules
$ kubectl apply -k 'https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/nfd/overlays/node-feature-rules?ref=<RELEASE_VERSION>'
```

--------------------------------

### View Logs for Demo Pods

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/dlb_plugin/README.md

Retrieves the logs for a specified demo pod. Replace '<pf/vf>' with the appropriate container name if necessary. This is useful for debugging issues, especially if a pod fails to start.

```bash
$ kubectl logs dlb-libdlb-demo <pf/vf>
```

```bash
$ kubectl logs dlb-dpdk-demo <pf/vf>
```

--------------------------------

### Get GpuDevicePlugin Status

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/OPENSHIFT.md

Verify the status and configuration of your GpuDevicePlugin by retrieving its details using oc get.

```bash
oc get GpuDevicePlugin
```

--------------------------------

### Deploy FPGA Plugin via Kustomize

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/fpga_plugin/README.md

Apply the FPGA plugin configuration based on the required mode. Replace <RELEASE_VERSION> with the desired tag or 'main'.

```bash
$ kubectl apply -k 'https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/fpga_plugin/overlays/af?ref=<RELEASE_VERSION>'
namespace/intelfpgaplugin-system created
customresourcedefinition.apiextensions.k8s.io/acceleratorfunctions.fpga.intel.com created
customresourcedefinition.apiextensions.k8s.io/fpgaregions.fpga.intel.com created
mutatingwebhookconfiguration.admissionregistration.k8s.io/intelfpgaplugin-mutating-webhook-configuration created
clusterrole.rbac.authorization.k8s.io/intelfpgaplugin-manager-role created
clusterrole.rbac.authorization.k8s.io/intelfpgaplugin-node-getter created
clusterrolebinding.rbac.authorization.k8s.io/intelfpgaplugin-get-nodes created
clusterrolebinding.rbac.authorization.k8s.io/intelfpgaplugin-manager-rolebinding created
service/intelfpgaplugin-webhook-service created
deployment.apps/intelfpgaplugin-webhook created
daemonset.apps/intelfpgaplugin-fpgadeviceplugin created
certificate.cert-manager.io/intelfpgaplugin-serving-cert created
issuer.cert-manager.io/intelfpgaplugin-selfsigned-issuer created
```

```bash
$ kubectl apply -k 'https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/fpga_plugin/overlays/region?ref=<RELEASE_VERSION>'
namespace/intelfpgaplugin-system created
customresourcedefinition.apiextensions.k8s.io/acceleratorfunctions.fpga.intel.com created
customresourcedefinition.apiextensions.k8s.io/fpgaregions.fpga.intel.com created
mutatingwebhookconfiguration.admissionregistration.k8s.io/intelfpgaplugin-mutating-webhook-configuration created
clusterrole.rbac.authorization.k8s.io/intelfpgaplugin-manager-role created
clusterrole.rbac.authorization.k8s.io/intelfpgaplugin-node-getter created
clusterrolebinding.rbac.authorization.k8s.io/intelfpgaplugin-get-nodes created
clusterrolebinding.rbac.authorization.k8s.io/intelfpgaplugin-manager-rolebinding created
service/intelfpgaplugin-webhook-service created
deployment.apps/intelfpgaplugin-webhook created
daemonset.apps/intelfpgaplugin-fpgadeviceplugin created
certificate.cert-manager.io/intelfpgaplugin-serving-cert created
issuer.cert-manager.io/intelfpgaplugin-selfsigned-issuer created
```

--------------------------------

### Speed up Image Builds with Vendor and Licenses

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/DEVEL.md

Pre-create Go licenses and bring libraries into the builder container to significantly speed up the build process for container images.

```bash
$ make vendor
$ make licenses
```

--------------------------------

### Install controller-gen

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/DEVEL.md

Installs the controller-gen tool, which is necessary for generating CRD and Webhook artifacts. Ensure you specify the desired release version.

```bash
GO111MODULE=on go get -u sigs.k8s.io/controller-tools/cmd/controller-gen@<release ver>, e.g, v0.4.1
```

--------------------------------

### Create QAT Provisioning ConfigMap

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/qat_plugin/README.md

Creates a ConfigMap for QAT provisioning from a file or literal values.

```bash
$ kubectl create configmap --namespace=inteldeviceplugins-system qat-config --from-file=/path/to/qat.conf
```

```bash
$ kubectl create configmap --namespace=inteldeviceplugins-system --from-literal "qat.conf=ServicesEnabled=<option>" qat-config
```

--------------------------------

### Uninstall Intel Device Plugins and Components

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/INSTALL.md

Commands to uninstall installed components. Repeat the plugin uninstall command for each plugin installed. Ensure you are in the correct namespace.

```bash
# repeat first step as many times as there are plugins installed
helm uninstall -n inteldeviceplugins-system <PLUGIN>
helm uninstall -n inteldeviceplugins-system dp-operator
helm uninstall -n node-feature-discovery nfd
helm uninstall -n cert-manager cert-manager
```

--------------------------------

### Deploy and Review Demo Workload

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/npu_plugin/README.md

Commands to apply the demo job and inspect the resulting pod logs.

```bash
$ kubectl apply -f ${INTEL_DEVICE_PLUGINS_SRC}/demo/intel-npu-workload.yaml
```

```bash
$ kubectl get pods | fgrep npu-workload
# substitute the 'xxxxx' below for the pod name listed above
$ kubectl logs npu-workload-xxxxx
```

--------------------------------

### Install Intel Device Plugins Operator Subscription

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/OPENSHIFT.md

Applies a Subscription resource to install the Intel Device Plugins Operator in the 'openshift-operators' namespace. This enables automatic updates.

```yaml
apiVersion: operators.coreos.com/v1alpha1
kind: Subscription
metadata:
  labels:
    operators.coreos.com/intel-device-plugins-operator.openshift-operators: ""
  name: intel-device-plugins-operator
  namespace: openshift-operators
spec:
  channel: stable
  installPlanApproval: Automatic
  name: intel-device-plugins-operator
  source: certified-operators
  sourceNamespace: openshift-marketplace
```

--------------------------------

### Deploy QAT Plugin via Kustomize

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/qat_plugin/README.md

Deploys the QAT device plugin using a remote Kustomize base. Replace <RELEASE_VERSION> with a specific tag or 'main'.

```bash
$ kubectl apply -k 'https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/qat_plugin?ref=<RELEASE_VERSION>'
```

--------------------------------

### Build Intel SGX Demo Images

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/sgx_plugin/README.md

Builds the container images for the Intel SGX SDK and aesmd demo. Ensure the INTEL_DEVICE_PLUGINS_SRC environment variable is set.

```bash
$ cd ${INTEL_DEVICE_PLUGINS_SRC}
$ make sgx-aesmd-demo
```

```bash
$ make sgx-sdk-demo
```

--------------------------------

### Deploy Webhook with Cert-Manager

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/sgx_admissionwebhook/README.md

Apply the default webhook configuration using kustomize and cert-manager.

```bash
$ kubectl apply -k https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/sgx_admissionwebhook/overlays/default-with-certmanager?ref=main
```

--------------------------------

### NPU Plugin Resource Request

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/README.md

Example of a Pod specification requesting NPU resources.

```yaml
apiVersion: "v1"
kind: Pod
metadata:
  name: intel-npu-sample-pod
spec:
  containers:
    - name: npu-container
      image: <registry>/<image>:<version>
      resources:
        limits:
          npu.intel.com/accel: 1
```

--------------------------------

### IAA Plugin Resource Request

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/README.md

Example of a Pod specification requesting IAA resources.

```yaml
apiVersion: "v1"
kind: Pod
metadata:
  name: iaa-accel-config-sample-pod
spec:
  containers:
    - name: iaa-container
      image: <registry>/<image>:<version>
      resources:
        limits:
          iaa.intel.com/wq-user-shared: 1
```

--------------------------------

### Build All Container Images

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/DEVEL.md

Build all container images for the device plugins. This can be a slow process. It's recommended to run 'make vendor' and 'make licenses' first to speed up subsequent builds.

```bash
$ make images
```

--------------------------------

### Configure DPDK DSA workqueue

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/dsa_plugin/README.md

Example JSON configuration for a DPDK-compatible DSA workqueue.

```default
{
  "dev":"wqX.0",
  "mode":"dedicated",
  "size":16,
  "group_id":0,
  "priority":10,
  "block_on_fault":1,
  "type":"user",
  "name":"dpdk_X0",
  "driver_name":"user",
  "threshold":15
}
```

--------------------------------

### Run Go unit tests for plugin binary

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/DEVEL.md

Execute Go unit tests for a specific plugin binary using `make test` and specifying the target path.

```bash
make test WHAT=./cmd/<plugin>
```

--------------------------------

### SGX Plugin Resource Request

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/README.md

Example of a Pod specification requesting SGX EPC resources.

```yaml
apiVersion: "v1"
kind: Pod
metadata:
  name: intelsgx-sample-pod
spec:
  containers:
    - name: sgx-container
      image: <registry>/<image>:<version>
      resources:
        limits:
          sgx.intel.com/epc: 1
```

--------------------------------

### Get QatDevicePlugin Status

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/OPENSHIFT.md

Check the status of deployed QatDevicePlugin custom resources in your OpenShift cluster.

```bash
oc get QatDevicePlugin
```

--------------------------------

### Run Plugin Binary Locally

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/DEVEL.md

Execute a built plugin binary on your development system. This requires administrator privileges.

```bash
$ sudo -E ${INTEL_DEVICE_PLUGINS_SRC}/cmd/<plugin-build-target>/<plugin-build-target>
```

--------------------------------

### DSA Plugin Resource Request (VFIO)

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/README.md

Example of a Pod specification requesting DSA VFIO resources.

```yaml
apiVersion: "v1"
kind: Pod
metadata:
  name: dsa-vfio-sample-pod
spec:
  containers:
    - name: dsa-container
      image: <registry>/<image>:<version>
      resources:
        limits:
          dsa.intel.com/vfio: 1
```

--------------------------------

### DLB Plugin Resource Request

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/README.md

Example of a Pod specification requesting DLB resources (pf or vf).

```yaml
apiVersion: "v1"
kind: Pod
metadata:
  name: dlb-sample-pod
spec:
  containers:
    - name: dlb-container
      image: <registry>/<image>:<version>
      resources:
        limits:
          dlb.intel.com/pf: 1
```

--------------------------------

### Tigerlake iGPU NFD Labels

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/gpu_plugin/labels.md

Example labels generated for a Tigerlake iGPU based on its PCI ID.

```default
gpu.intel.com/device-id.0300-9a49.count=1
gpu.intel.com/device-id.0300-9a49.present=true
```

--------------------------------

### Deploy GPU Plugin with XPUMD Health Source

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/gpu_plugin/README.md

Apply the Kustomize overlay to deploy the GPU plugin using Intel XPU Manager (xpumd) for health monitoring. This overlay automatically configures necessary mounts and flags.

```bash
kubectl apply -k 'https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/gpu_plugin/overlays/xpumd?ref=<RELEASE_VERSION>'
```

--------------------------------

### FPGA Tool Usage and Options

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/fpga_tool/README.md

Command line flags and options for configuring the FPGA tool operations.

```bash
Usage of ./fpga_tool:
  -b string
        Path to bitstream file (GBS or AOCX)
  -d string
        Path to device node (FME or Port)
  -dry-run
        Don't write/program, just validate and log
  -force
        Force overwrite operation for installing bitstreams
  -q    Quiet mode. Only errors will be reported
```

--------------------------------

### Build containers with RPM dependencies using Podman

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/DEVEL.md

Build containers with RPM dependencies by setting `UBI=1` and `BUILDER=podman` and using `make`. This requires the build host to be registered with `subscription-manager` and typically uses Podman.

```bash
UBI=1 BUILDER=podman make <image-name>
```

--------------------------------

### Deploy Intel IAA Device Plugin

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/iaa_plugin/README.md

Use this command to deploy the Intel IAA device plugin using pre-built images. Replace `<RELEASE_VERSION>` with the desired release tag or 'main' for development images.

```bash
$ kubectl apply -k 'https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/iaa_plugin?ref=<RELEASE_VERSION>'
daesmonset.apps/intel-iaa-plugin created
```

--------------------------------

### DSA Plugin Resource Request (Shared)

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/README.md

Example of a Pod specification requesting DSA shared work queue resources.

```yaml
apiVersion: "v1"
kind: Pod
metadata:
  name: dsa-accel-config-sample-pod
spec:
  containers:
    - name: dsa-container
      image: <registry>/<image>:<version>
      resources:
        limits:
          dsa.intel.com/wq-user-shared: 1
```

--------------------------------

### List Device Plugin Labels in Samples

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/operator/README.md

Lists all device-specific feature labels defined in the operator samples directory. This helps identify available labels for different Intel hardware.

```bash
$ grep -r feature.node.kubernetes.io/ deployments/operator/samples/
deployments/operator/samples/deviceplugin_v1_dlbdeviceplugin.yaml:    intel.feature.node.kubernetes.io/dlb: 'true'
deployments/operator/samples/deviceplugin_v1_qatdeviceplugin.yaml:    intel.feature.node.kubernetes.io/qat: 'true'
deployments/operator/samples/deviceplugin_v1_sgxdeviceplugin.yaml:    intel.feature.node.kubernetes.io/sgx: 'true'
deployments/operator/samples/deviceplugin_v1_gpudeviceplugin.yaml:    intel.feature.node.kubernetes.io/gpu: "true"
deployments/operator/samples/deviceplugin_v1_fpgadeviceplugin.yaml:    intel.feature.node.kubernetes.io/fpga-arria10: 'true'
deployments/operator/samples/deviceplugin_v1_dsadeviceplugin.yaml:    intel.feature.node.kubernetes.io/dsa: 'true'
```

--------------------------------

### List FPGA Tool Commands

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/fpga_tool/README.md

Available subcommands for the FPGA test tool.

```bash
info, fpgainfo, install, list, fmeinfo, portinfo, list-fme, list-port, pr, release, assign
```

--------------------------------

### Get DSA Device Plugin Status

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/OPENSHIFT.md

Verify the status and configuration of the DSA Device Plugin by querying the Kubernetes API.

```bash
oc get DsaDevicePlugin
```

--------------------------------

### Get SGX Device Plugin Status

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/OPENSHIFT.md

Verify the status and configuration of the SGX Device Plugin by querying the Kubernetes API.

```bash
oc get SgxDevicePlugin
```

--------------------------------

### Create Custom Provisioning ConfigMap

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/dsa_plugin/README.md

Create a Kubernetes ConfigMap named 'intel-dsa-config' in the 'inteldeviceplugins-system' namespace to store custom provisioning configurations. The configuration file 'demo/dsa.conf' is used as the source.

```bash
$ kubectl create configmap --namespace=inteldeviceplugins-system intel-dsa-config --from-file=demo/dsa.conf

```

--------------------------------

### Deploy QAT DPDK Application

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/qat_plugin/README.md

Apply the Kustomization for the QAT DPDK application to deploy both crypto and compress performance testing pods.

```bash
$ kubectl apply -k https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/qat_dpdk_app/
```

--------------------------------

### MAX 1550 Data Center GPU Labels

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/gpu_plugin/labels.md

Example labels generated for a MAX 1550 GPU, including family and product details.

```default
gpu.intel.com/device.count=2
gpu.intel.com/family=Max_Series
gpu.intel.com/product=Max_1550
```

--------------------------------

### Deploy QAT Plugin in Debug Mode

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/qat_plugin/README.md

Deploys the QAT device plugin with debug mode enabled using a specific Kustomize overlay.

```bash
$ kubectl apply -k 'https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/qat_plugin/overlays/debug?ref=<RELEASE_VERSION>'
```

--------------------------------

### Flex 170 Data Center GPU Labels

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/gpu_plugin/labels.md

Example labels generated for a Flex 170 GPU, including family and product details.

```default
gpu.intel.com/device.count=1
gpu.intel.com/family=Flex_Series
gpu.intel.com/product=Flex_170
```

--------------------------------

### Apply DLB LibDLB Demo Pod Manifest

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/dlb_plugin/README.md

Creates a pod in Kubernetes to run the dlb-libdlb-demo unit tests. Ensure the INTEL_DEVICE_PLUGINS_SRC environment variable is set to the source directory of the plugin.

```bash
$ kubectl apply -f ${INTEL_DEVICE_PLUGINS_SRC}/demo/dlb-libdlb-demo-pod.yaml
```

--------------------------------

### Deploy SGX DCAP Quote Generation Sample

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/sgx_plugin/README.md

Deploys a sample application that runs SGX DCAP Quote Generation. Ensure the PCCS URL is set beforehand.

```bash
$ kubectl apply -k 'https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/sgx_enclave_apps/overlays/sgx_ecdsa_aesmd_quote?ref=<RELEASE_VERSION>'
```

--------------------------------

### Run Operator Bundle

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/DEVEL.md

Runs the operator bundle using the operator-sdk. Replace '<Registry>:<Tag>' with your image registry and tag. The operator will be installed in the 'testoperator' namespace.

```bash
operator-sdk run bundle <Registry>:<Tag> -n testoperator
```

--------------------------------

### Generate CRD and Webhook Artifacts

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/DEVEL.md

Generates Custom Resource Definition (CRD) and Webhook artifacts using the controller-gen tool. This command should be run after installing controller-gen.

```bash
make generate
```

--------------------------------

### Build Plugin Binaries

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/DEVEL.md

Build plugin binaries using the Makefile. Replace '<plugin-build-target>' with the specific plugin you want to build. Ensure you have a Go development environment set up.

```bash
$ cd ${INTEL_DEVICE_PLUGINS_SRC}
$ make <plugin-build-target>
```

--------------------------------

### Create GPU Demo Job

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/gpu_plugin/README.md

Applies the intelgpu-job.yaml manifest to create a Kubernetes job for demonstrating GPU plugin functionality.

```bash
$ kubectl apply -f ${INTEL_DEVICE_PLUGINS_SRC}/demo/intelgpu-job.yaml
job.batch/intelgpu-demo-job created
```

--------------------------------

### Deploy Compress Performance Test Pod

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/qat_plugin/README.md

Apply the Kustomization specifically for the compress-perf component of the QAT DPDK application.

```bash
$ kubectl apply -k https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/qat_dpdk_app/compress-perf
```

--------------------------------

### Deploy IAA Device Plugin with Init Container

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/iaa_plugin/README.md

Deploy the Intel IAA device plugin with an included init container that provisions IAA devices and workqueues. This uses a default configuration.

```bash
$ kubectl apply -k deployments/iaa_plugin/overlays/iaa_initcontainer/
```

--------------------------------

### Run Tests with Kind (No Cluster)

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/DEVEL.md

Execute tests without a pre-configured Kubernetes cluster by using the 'make test-with-kind' command. Ensure Kind is installed on your host machine.

```bash
make test-with-kind
```

--------------------------------

### Apply DLB DPDK Demo Pod Manifest

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/dlb_plugin/README.md

Creates a pod in Kubernetes to run the dlb-dpdk-demo unit tests. Ensure the INTEL_DEVICE_PLUGINS_SRC environment variable is set to the source directory of the plugin.

```bash
$ kubectl apply -f ${INTEL_DEVICE_PLUGINS_SRC}/demo/dlb-dpdk-demo-pod.yaml
```

--------------------------------

### Add Intel Helm Charts Repository

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/README.md

Add the Intel Helm Charts repository to your Helm configuration. This is necessary to install Kubernetes resources for the device plugins framework.

```bash
helm repo add intel https://intel.github.io/helm-charts
```

--------------------------------

### Deploy Intel Device Plugin Operator

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/sgx_plugin/README.md

Apply the Intel Device Plugin operator using the default configuration. Refer to operator deployment details for proxy setup.

```bash
kubectl apply -k 'https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/operator/default?ref=<RELEASE_VERSION>'
```

--------------------------------

### List GPU PCI IDs using lspci

Source: https://github.com/intel/intel-device-plugins-for-kubernetes/blob/main/cmd/gpu_plugin/driver-firmware.md

This command lists PCI devices, filtering for those with 'VGA' or 'Display' controllers that are from Intel. This helps identify the specific GPU hardware installed.

```bash
$ lspci | grep -e VGA -e Display | grep Intel
88:00.0 Display controller: Intel Corporation Device 56c1 (rev 05)
8d:00.0 Display controller: Intel Corporation Device 56c1 (rev 05)
```