Open Sourcing Kubex’s GPU Process Exporter: Gain Visibility in Your Shared GPUs

 GPU sharing with NVIDIA hardware is becoming easier to adopt in Kubernetes but it hasn’t been easier to observe.  

Time-slicing lets multiple workloads share the same GPU. MPS allows CUDA workloads to execute concurrently. Schedulers like KAI make it easier to manage these shared environments. 

But sharing a GPU introduces a problem that is easy to underestimate: 

Who and what is actually using it? 

Most GPU observability starts at the device level. You can see utilization, memory usage, temperature, power consumption, and other hardware metrics. 

That works well when one container owns one GPU. 

When several containers share that GPU, device-level metrics no longer tell you which workload is responsible for what you’re seeing. 

That’s why we’re open sourcing our GPU Process Exporter. 

Kubex’s GPU Process Exporter brings utilization and memory usage down to the Kubernetes container level for pods running on your NVIDIA hardware. It maps GPU processes back to the pods and containers they belong to, giving operators visibility into what each workload is actually doing on a shared GPU. 

Instead of seeing that a GPU is 90% utilized, you can see which containers are driving that utilization. 

It plugs into Prometheus, comes with a Helm chart for deployment, and includes a Grafana dashboard so you can start exploring shared GPU usage on the observability stack you already have. 

Shared GPUs create an observability gap 

Imagine a GPU sitting at 90% utilization with four inference workloads sharing it. 

Using traditional GPU observability tools, you’re left with these questions: 

• Which workload is driving that utilization? 
• Is one container consuming most of the GPU while the others barely run? 
• How is GPU memory distributed between them? 
• Are workloads actually using the GPU capacity you’ve allocated to them? 

These are basic questions for a platform operator, but they become difficult to answer with software-based GPU sharing. 

Device-level telemetry remains useful for GPU health and infrastructure monitoring. What it doesn’t give you is attribution back to individual Kubernetes workloads. 

Our GPU Process Exporter adds that missing layer. 

Container-level GPU metrics 

The exporter reads per-process metrics from NVIDIA’s NVML APIs and maps those processes back to the Kubernetes pods and containers running them. 

The resulting Prometheus metrics include Kubernetes context such as: 

• namespace 
• pod 
• container 
• node 
• GPU UUID 
• GPU model 

Instead of seeing only that a GPU is busy, you can see which containers are using it. 

The exporter exposes container-level GPU memory usage and utilization metrics alongside GPU requests and limits. This gives operators a way to compare what a workload was allocated with what it is actually consuming. 

That visibility is especially important with time-slicing and MPS, where several containers are using the same physical GPU. 

Why we’re open sourcing it 

We built the GPU Process Exporter because we needed this visibility while working on GPU sharing in Kubex. 

We quickly realized the problem extends well beyond our own platform. 

More Kubernetes teams are experimenting with time-slicing, MPS, the KAI Scheduler, HAMi and other approaches to GPU sharing. Once multiple workloads start sharing the same hardware, understanding usage at the container level becomes increasingly important. 

So we’re open sourcing GPU Process Exporter under Apache 2.0. 

If you’re running shared NVIDIA GPUs in Kubernetes, give it a try. 

Install the Helm chart, import the Grafana dashboard, run some workloads on a shared GPU, and see what is actually happening on the device. 

If you find something missing, open an issue or send us a PR. 

See our repo on GitHub: densify-dev/gpu-process-exporter