Tutorials
Hands-on tutorials for learning HAMi by doing. Each lab is a step-by-step exercise with real, captured outputs: you build a cluster, install HAMi, and verify GPU partitioning behavior yourself.
Concepts
Background knowledge that the labs build on.
- GPU Software Stack Overview: the 5 layers from hardware to Kubernetes scheduling
- Understanding GPU Drivers: kernel modules, NVML, and how to troubleshoot from the bottom up
- HAMi Cluster Architecture: every component in a HAMi cluster and what breaks without it
Labs
Build a GPU Kubernetes cluster from scratch on a cloud VM and install HAMi.
Learn the HAMi control plane on a laptop, no GPU required.
Run multiple Pods on one GPU with enforced VRAM and compute limits.
The same outcome through Kubernetes-native Dynamic Resource Allocation (experimental).
Simulate 8 A100 GPUs with HAMi scheduling features, no real GPU needed.
Install HAMi on a GPU cluster and schedule vLLM inference services with GPU partitioning.
Share one non-MIG GPU between Pods on single-node k3s and prove HAMi-core enforces the memory cap.
Share one GPU with Volcano vGPU, then verify Gang scheduling and queue-level vGPU limits.
Enforce vGPU count, memory, and compute quotas for HAMi workloads before Pods reach the scheduler.
Simulate an asymmetric PCIe topology and verify HAMi's topology-aware scheduler avoids a poorly-connected GPU for multi-GPU requests and picks it for single-GPU requests, no real GPU required.
Deploy a KServe Standard vLLM service and run two Predictor replicas on one NVIDIA GPU through native HAMi DRA claims.
Deploy KAI Scheduler and kai-resource-isolator on GKE, adapt the COS/CDI runtime path, and prove per-Pod GPU memory isolation with CUDA allocations.
Build Volcano and the ascend-device-plugin from source on an aarch64 Ascend server, enable hami-vnpu-core soft slicing, and verify memory isolation, binpack card sharing, and per-container metrics.
Install HAMi v2.10.0 on a GKE node with four Tesla T4s and observe spread, binpack, mutex, and the composed mutex,binpack chain through allocation annotations and scheduler logs.
Install HAMi on a GPU cluster and schedule SGLang inference services with GPU partitioning.
Install HAMi v2.10.0 and verify per-Pod MIG placement, mixed profiles, selective reclamation, restart recovery, and multi-GPU spillover.
Package a model as a KitOps ModelKit, pull it from Jozu Hub with an initContainer, and serve it locally with SGLang (and optionally vLLM) on HAMi GPU shares.
Two physical GPUs, one cluster, twelve proofs. What HAMi isolates, what it can't, and how a service mesh sees the difference and routes around it.
Install HAMi 2.10.0 and the Ascend device plugin, then verify template matching, multi-Pod sharing, capacity exhaustion, whole-card exclusion, and monitoring on an Ascend 310P3.
Each lab lists its own prerequisites.
- Labs 3 and 4 continue from the cluster Lab 1 builds, so a single session covers all three.
- Lab 2 runs on any laptop with no GPU required.
- Lab 7 brings up its own single-node k3s cluster on a rented GPU VM, without the GPU Operator.
- Lab 8 requires an existing Volcano GPU cluster and validates Volcano vGPU, Gang scheduling, and queue-level limits.
- Lab 9 uses Kueue admission control to enforce HAMi vGPU count, memory, and compute quotas.
- Lab 11 builds a complete KServe Standard inference stack and runs two vLLM replicas on one GPU through native HAMi DRA claims.
- Lab 12 deploys KAI Scheduler and HAMi-core on GKE 1.35/COS/CDI and proves the memory ceiling with CUDA allocations.
- Lab 13 builds Volcano and the ascend-device-plugin from source on an Ascend 310P3 ARM server and verifies hami-vnpu-core soft slicing, binpack card sharing, and per-container metrics.
- Lab 14 installs HAMi v2.10.0 on a four-T4 GKE node and observes the composable
gpu-scheduler-policychains (spread,binpack,mutex,mutex,binpack) through allocation annotations and scheduler logs. - Lab 16 installs HAMi v2.10.0 on a seven-GPU RTX PRO 6000 server and verifies the complete Dynamic MIG lifecycle: per-Pod placement, mixed profiles, selective reclamation, device-plugin restart recovery, and spillover to a second GPU.
- Lab 17 packages a model as a KitOps ModelKit, pulls it from Jozu Hub through an initContainer, and serves it with SGLang and optionally vLLM on HAMi GPU shares.
- Lab 19 installs HAMi 2.10.0 and the Ascend device plugin on a 310P3 node, then verifies template-based hard slicing (
vir01,vir02, andvir04), multi-Pod sharing, capacity exhaustion, whole-card exclusion, and allocation metrics.
