GUIDE / KUBERNETES · BUSINESS WORKLOADS

    AI and GPU Workloads on Kubernetes: Use Expensive Accelerators Without Losing Control

    A GPU Pod can be Running while the business service stays unhealthy — the model still loading, the queue growing, or the weights unreachable. The objective is reliable output, not maximum utilization.

    Updated July 2026·16 min read·Business Workload series
    01

    The objective is not maximum GPU allocation

    Kubernetes can provide a common platform for AI inference, training, data preparation and batch scoring. It does not automatically make accelerator workloads efficient, portable, fairly scheduled, cost effective, or recoverable.

    The objective is reliable business output from a controlled amount of accelerator capacity — the business metric should be cost per valid outcome, not cost per device-hour.

    02

    Common AI workload patterns

    PatternTypical needs
    Online inferencePredictable latency, warm replicas, traffic routing, request queuing, autoscaling
    Batch inferenceKubernetes Jobs track work until required completions are reached; needs durable input/output and retry-safe behaviour
    Model trainingOne or several accelerators, high-speed networking, checkpoints, coordinated worker startup
    Fine-tuningFull or parameter-efficient training on a business dataset — security must cover dataset, weights and checkpoints
    Data preparationOften CPU/storage/network intensive rather than GPU intensive — don't occupy accelerators with this work
    03

    CPU or GPU? Device plugins and Dynamic Resource Allocation

    Use CPUs when latency is acceptable, throughput is modest, or the model is small — use accelerators only when measurement shows a material improvement in latency, throughput, or cost per request. A GPU can reduce elapsed time while increasing hourly cost.

    SOURCE / Kubernetes documentation

    Device plugins advertise specialized resources such as GPUs to the kubelet so the scheduler can place Pods that request them. Kubernetes includes stable support for scheduling AMD and NVIDIA GPUs through compatible device plugins.

    SOURCE / Dynamic Resource Allocation

    DRA is a newer framework for requesting and allocating accelerator devices by attribute rather than resource name alone. The core DRA functionality became generally available in Kubernetes 1.34, with later releases adding further stable capabilities — exact behaviour depends on the installed version and driver.

    ×A complete GPU node still requires compatible hardware, host driver, container-runtime integration, device plugin and monitoring exporter. Kubernetes does not install and validate every vendor driver automatically.
    04

    Sharing models

    ModelTrade-off
    Whole-device allocationPredictable memory, strong isolation — but poor utilization for small models and higher cost
    Hardware partitioningDedicated memory/compute slices, stronger isolation than time sharing — can fragment capacity
    Time sharingHigher utilization for intermittent inference — variable latency and weaker memory isolation
    Model-server multiplexingGood for small, intermittent models — one server or GPU failure can affect several models at once

    Choose dedicated devices when performance and isolation matter more than utilization. Do not describe a time-shared GPU as equivalent to an exclusive one.

    05

    Model serving

    Models may load from a container image (reproducible, but slow pulls for large models), object storage (independent lifecycle, but download time and credentials to manage), or a PersistentVolume (fast local access, but storage attachment and backup dependencies).

    SOURCE / Model warm-up

    Large models may require substantial time to download, deserialize, allocate GPU memory and compile kernels. Use a startup probe so traffic doesn't reach the Pod before initialization completes, and measure warm-up time for a cold node, cold image and cold model cache separately.

    Readiness should confirm the model is loaded and a sample inference succeeds — not merely that the HTTP process started. Liveness should never depend on a temporarily unavailable model registry or optional telemetry, or a shared outage can trigger a fleet-wide restart loop.

    KServe provides Kubernetes custom resources and controllers for serving predictive and generative AI models, with deployment modes that integrate with serverless or high-density serving components. It can simplify serving, but it also introduces controllers and CRDs that must be backed up and recovered like any other platform dependency.

    06

    Autoscaling inference

    The HorizontalPodAutoscaler can scale supported workloads from resource, custom or external metrics — useful inference signals include queue depth, concurrent requests, tokens per second and accelerator saturation.

    ×GPU utilization is not always enough. High utilization may indicate overload; low utilization may indicate a memory-bound model or an external bottleneck rather than wasted capacity.
    ×GPU inference scale-up includes HPA metric delay, node provisioning, driver initialization, image pull, model download and warm-up — this can take far longer than ordinary web application scale-up. Customer-facing inference may need minimum warm replicas rather than relying on scale-up speed.

    Scale-to-zero can cut cost for infrequently used models but introduces cold-start latency — evaluate model size, download time and customer timeout before using it for anything with a strict first-response deadline.

    07

    Distributed training and checkpoints

    Kubeflow Trainer is a Kubernetes-native platform for distributed training and fine-tuning across frameworks including PyTorch, JAX and XGBoost. It doesn't remove the need to define checkpoint frequency, dataset access, retry behaviour, or accelerator topology.

    ×Some distributed training workloads cannot make progress unless all required workers start together. Scheduling workers independently can leave idle allocated GPUs, worker timeouts and repeated restarts — evaluate whether your scheduler supports gang scheduling.

    Store checkpoints (model weights, optimizer state, training step, random state) outside the Pod filesystem — object storage, shared filesystem, or a managed training repository — and test restarting from a checkpoint after Pod, node and cluster loss, not just after a clean shutdown.

    08

    Security, privacy and model theft

    AI workloads may expose business data, customer prompts, training datasets, model weights and API credentials. A user who can create an arbitrary Pod with access to the model PVC or object-store identity may be able to copy the model — review effective privilege, not just resource names.

    ×Do not log full prompts and outputs by default. Inference logs and traces may contain customer documents, personal data or proprietary code.
    ×GPU nodes require vendor software and device access — do not assume application Pods need privileged mode. Separate node-maintenance privileges from model-deployment permissions.
    09

    Observability and cost

    Monitor four layers: cluster (Pending Pods, scheduler latency), accelerator (GPU utilization, memory, temperature, errors), model server (queue depth, latency, token rate), and business (valid prediction rate, conversion, cost per request).

    SOURCE / Model quality is not infrastructure health

    A model can be fast but inaccurate, available but biased, or correctly deployed but using the wrong version. Monitor accuracy, drift, rejection rate and unsafe-output rate according to the application — not only Pod and GPU status.

    Useful unit costs include cost per 1,000 inferences, cost per million tokens, and cost per training run. Idle GPU capacity may be justified by latency objectives or failure reserve — label justified reserve separately from accidental waste, since usage-only chargeback can undervalue capacity reserved for availability.

    10

    Backup and disaster recovery

    Protect Kubernetes resources, serving/training CRDs, model registry metadata, model weights, training checkpoints, evaluation results, container images and Secrets. Model artefacts should normally exist outside the source cluster — a PersistentVolume containing the only model copy creates unnecessary recovery risk.

    ×A cluster restored without compatible GPUs may remain technically operational but unable to serve the model. Confirm the recovery region has the required accelerator type, provider quota and reserved capacity before relying on it — GPU capacity can be harder to obtain than ordinary compute during a regional incident.

    Some models can provide degraded CPU inference during accelerator failure — evaluate and load-test this fallback rather than assuming it works. See the disaster recovery plan guide for the broader recovery framework.

    11

    Common mistakes

    ×Requesting GPUs without measuring the CPU baseline

    The workload may not need an accelerator. Compare cost per valid outcome.

    ×Treating all GPUs as interchangeable

    Memory, architecture, driver and interconnect requirements may differ. Define compatible device classes.

    ×Autoscaling on GPU utilization alone

    Utilization may not reflect queue delay, memory, or customer latency. Use demand and service metrics.

    ×Loading models only from the Pod filesystem

    Pod replacement removes the only model copy. Use an external model store.

    ×Reporting readiness before the model is loaded

    Traffic reaches a process that cannot yet perform inference. Validate a loaded model, not just a running process.

    ×Logging full prompts and outputs

    Logs may expose confidential or personal data. Redact and control retention.

    ×Mixing training and critical inference without resource controls

    Training can consume the capacity needed by customers. Separate priorities or node pools.

    ×Running long training without checkpoints

    One interruption loses the complete run. Store durable checkpoints.

    ×Assuming recovery-region GPUs will be available

    Accelerator quota and supply may differ by region. Verify capacity and test recovery.

    12

    AI and GPU workload checklist

    0 / 25
    13

    Frequently asked questions

    Yes. Kubernetes supports GPU scheduling through compatible vendor device plugins.

    It is a plugin framework that advertises specialized hardware resources, such as GPUs, to the kubelet for workload allocation.

    DRA is a Kubernetes framework for requesting and allocating devices and other specialized resources using driver-defined device classes and claims. The core framework became generally available in Kubernetes 1.34, with later releases adding further stable capabilities.

    Possibly, through hardware partitioning, vendor time sharing, DRA-supported sharing, or model-server multiplexing. Exact isolation and behaviour depend on the hardware and integration.

    They can, but separate pools often provide better priority, performance, cost and failure isolation.

    Yes. HPA can scale supported workloads using resource, custom or external metrics — the metric system and accelerator capacity must be available.

    KServe is a Kubernetes-native model-serving platform that uses custom resources and controllers to manage predictive and generative inference workloads.

    Small, stable models may be packaged with the image. Large or frequently updated models often fit better in a versioned model registry or object store.

    Create durable checkpoints containing enough training state to resume after Pod, node or cluster loss.

    Yes, when the workload is checkpointed, interruption tolerant and not bound to a strict immediate deadline.

    No. Validate the model version, model loading, inference output, latency, queueing and business outcome.

    It must schedule onto compatible hardware, meet latency and quality objectives, control cost and tenant access, survive expected failures, and recover its model and business function in the approved environment.

    Operate the AI service, not only the GPU

    Kubernetes can provide a strong control plane for AI inference and training — repeatable deployment, hardware scheduling, workload isolation and shared operations. Its risks appear when expensive accelerators are treated as ordinary interchangeable compute.

    Measure the CPU baseline, choose whole-device allocation, partitioning or sharing deliberately, store models and checkpoints outside the source cluster, scale from queueing and service demand rather than GPU utilization alone, and monitor model quality alongside infrastructure health. Test Pod loss, GPU-node loss, cold model loading and replacement-cluster recovery — then calculate cost per useful business outcome, not GPU utilization percentage.