Deploy with Helm#

Prerequisites#

System Requirements
Kubernetes Cluster: Ensure you have a properly installed and configured Kubernetes cluster.
Tools Installed: Install the required tools:
- Kubernetes CLI (kubectl)
- Helm 3 or later
For Helm installation, refer to Helm website

Intel NFD and Device Plugins (required for GPU/NPU workloads): Install Node Feature Discovery (NFD) and the Intel GPU/NPU device plugins to enable hardware detection and scheduling. This ensures pods requesting GPU or NPU resources are only deployed on nodes with available hardware. Refer to release tags for available versions (tested with v0.35.0):

# Pick a release version compatible with your cluster
export RELEASE_VERSION=v0.35.0

# Step 1: Create namespace for the Intel device plugins
kubectl create namespace intel-device-plugins

# Step 2: Allow privileged pods in the device plugin namespace
# Required because the plugin needs hostPath mounts and access to host device files.
kubectl label namespace intel-device-plugins \
  pod-security.kubernetes.io/enforce=privileged \
  pod-security.kubernetes.io/audit=privileged \
  pod-security.kubernetes.io/warn=privileged \
  --overwrite

# Step 3: Install Node Feature Discovery (NFD)
# NFD uses its own namespace: node-feature-discovery
kubectl apply -k "https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/nfd?ref=${RELEASE_VERSION}"

# Step 4: Allow privileged pods in the NFD namespace
kubectl label namespace node-feature-discovery \
  pod-security.kubernetes.io/enforce=privileged \
  pod-security.kubernetes.io/audit=privileged \
  pod-security.kubernetes.io/warn=privileged \
  --overwrite

# Step 5: Install Intel GPU NodeFeatureRules
# These rules let NFD detect and label Intel GPU nodes.
kubectl apply -k "https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/nfd/overlays/node-feature-rules?ref=${RELEASE_VERSION}"

# Step 6: Verify NFD pods are running
kubectl get pods -n node-feature-discovery

# Step 7: Verify the node got Intel GPU and NPU labels
kubectl get node $(hostname) --show-labels | tr ',' '\n' | grep intel

# Step 8: Install the Intel GPU device plugin
kubectl apply -n intel-device-plugins -k "https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/gpu_plugin/overlays/nfd_labeled_nodes?ref=${RELEASE_VERSION}"

# Step 9: Install the Intel NPU device plugin
kubectl apply -n intel-device-plugins -k "https://github.com/intel/intel-device-plugins-for-kubernetes/deployments/npu_plugin/overlays/nfd_labeled_nodes?ref=${RELEASE_VERSION}"

Verify the Intel Device Plugin pods are running:

kubectl get pods -n intel-device-plugins

Verify the GPU and NPU resources are advertised on nodes:

kubectl get nodes -o json | jq '.items[] | {name: .metadata.name, gpu: .status.allocatable["gpu.intel.com/i915"], npu: .status.allocatable["npu.intel.com/accel"]}'

Note: If your node uses Intel Xe discrete GPUs (Arc), set gpu: to .status.allocatable["gpu.intel.com/xe"].

Store Frames to S3 Storage#

Applications can take advantage of the S3 publish feature from DL Streamer Pipeline Server and use it to save frames to an S3 compatible storage.

Run the steps in the section above to set up the application.

Install the Helm chart.

helm install app-deploy helm -n apps --create-namespace

Copy the resources such as video and model from local directory to the dlstreamer-pipeline-server pod to make them available for application while launching pipelines.

Pallet Defect Detection

POD_NAME=$(kubectl get pods -n apps -o jsonpath='{.items[*].metadata.name}' | tr ' ' '\n' | grep deployment-dlstreamer-pipeline-server | head -n 1)

kubectl cp resources/pallet-defect-detection/videos/warehouse.avi $POD_NAME:/home/pipeline-server/resources/videos/ -c dlstreamer-pipeline-server -n apps

kubectl cp resources/pallet-defect-detection/models/* $POD_NAME:/home/pipeline-server/resources/models/ -c dlstreamer-pipeline-server -n apps

PCB Anomaly Detection

POD_NAME=$(kubectl get pods -n apps -o jsonpath='{.items[*].metadata.name}' | tr ' ' '\n' | grep deployment-dlstreamer-pipeline-server | head -n 1)

kubectl cp resources/pcb-anomaly-detection/videos/anomalib_pcb_test.avi $POD_NAME:/home/pipeline-server/resources/videos/ -c dlstreamer-pipeline-server -n apps

kubectl cp resources/pcb-anomaly-detection/models/* $POD_NAME:/home/pipeline-server/resources/models/ -c dlstreamer-pipeline-server -n apps

Install the package boto3 in your Python environment if not installed.

This guide recommends creating a virtual environment and installing it there. You can run the following commands to add the necessary dependencies as well as create and activate the environment.
```
sudo apt update && \
sudo apt install -y python3 python3-pip python3-venv
```
```
python3 -m venv venv && \
source venv/bin/activate
```
Once the environment is ready, install boto3 with the following command
```
pip3 install --upgrade pip && \
pip3 install boto3==1.36.17
```
Note: DL Streamer Pipeline Server expects the bucket to be already present in the database. The next step will help you create one.

Create an S3 bucket using the following script.

Update the host_IP and credentials with that of the running MinIO server. Use create_bucket.py as the file name.

import boto3
url = "http://<host_IP>:30800"
user = "<value of MINIO_ACCESS_KEY used in helm/values.yaml>"
password = "<value of MINIO_SECRET_KEY used in helm/values.yaml>"
bucket_name = "ecgdemo"

client= boto3.client(
            "s3",
            endpoint_url=url,
            aws_access_key_id=user,
            aws_secret_access_key=password
)
client.create_bucket(Bucket=bucket_name)
buckets = client.list_buckets()
print("Buckets:", [b["Name"] for b in buckets.get("Buckets", [])])

Run the above script to create the bucket.

python3 create_bucket.py

Start the pipeline with the following cURL command, with <host_IP> set to system IP address. Give the correct path to the model as seen below.

Note: If you are running Helm using an NGINX_HTTPS_PORT other than the default 30443, replace 30443 with <NGINX_HTTPS_PORT>.

Pallet Defect Detection

curl -k https://<host_IP>:30443/api/pipelines/user_defined_pipelines/pallet_defect_detection_s3write -X POST -H 'Content-Type: application/json' -d '{
    "source": {
        "uri": "file:///home/pipeline-server/resources/videos/warehouse.avi",
        "type": "uri"
    },
    "destination": {
        "frame": {
            "type": "webrtc",
            "peer-id": "pdds3"
        }
    },
    "parameters": {
        "detection-properties": {
            "model": "/home/pipeline-server/resources/models/pallet-defect-detection/deployment/Detection/model/model.xml",
            "device": "CPU"
        }
    }
}'

PCB Anomaly Detection

curl -k https://<host_IP>:30443/api/pipelines/user_defined_pipelines/pcb_anomaly_detection_s3write -X POST -H 'Content-Type: application/json' -d '{
   "source": {
       "uri": "file:///home/pipeline-server/resources/videos/anomalib_pcb_test.avi",
       "type": "uri"
   },
   "destination": {
       "frame": {
           "type": "webrtc",
           "peer-id": "anomaly_s3"
       }
   },
   "parameters": {
       "classification-properties": {
           "model": "/home/pipeline-server/resources/models/pcb-anomaly-detection/deployment/Anomaly classification/model/model.xml",
           "device": "CPU"
       }
   }
}'

Go to MinIO console on https://<host_IP>:30443/minio/ and login with MINIO_ACCESS_KEY and MINIO_SECRET_KEY provided in helm/values.yaml file. After logging into console, you can go to ecgdemo bucket and check the frames stored.

Note: If you are running Helm using an NGINX_HTTPS_PORT other than the default 30443, replace 30443 with <NGINX_HTTPS_PORT>.
Uninstall the Helm chart.
```
helm uninstall app-deploy -n apps
```