feat: initial release of headlamp-intel-gpu-plugin v0.1.0
Adds a Headlamp plugin for Intel GPU device plugin visibility: - Dedicated sidebar section: Overview, Device Plugins, GPU Nodes, GPU Pods - Native Node detail page injection: GPU capacity, allocatable, utilization, active pods - Native Pod detail page injection: per-container GPU resource requests/limits - Native Nodes table: GPU Type and GPU Devices columns - App bar health badge (hidden when plugin not installed) - GpuDevicePlugin CRD monitoring (deviceplugin.intel.com/v1) with graceful degradation when CRD is not present - Supports discrete (i915), Xe, and integrated GPU nodes via node labels - 48 unit tests, TypeScript clean, 28 kB production bundle Generated with [Claude Code](https://claude.ai/code) via [Happy](https://happy.engineering) Co-Authored-By: Claude <noreply@anthropic.com> Co-Authored-By: Happy <yesreply@happy.engineering>
This commit is contained in:
+393
@@ -0,0 +1,393 @@
|
||||
/**
|
||||
* Kubernetes type definitions and helper functions for Intel GPU device plugin resources.
|
||||
*
|
||||
* All K8s resource types are typed at the fields we actually use.
|
||||
* External data from the API is validated at the boundary before use.
|
||||
*/
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Intel GPU device plugin constants
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/** API group for Intel device plugin CRDs */
|
||||
export const INTEL_DEVICE_PLUGIN_API_GROUP = 'deviceplugin.intel.com';
|
||||
export const INTEL_DEVICE_PLUGIN_API_VERSION = 'v1';
|
||||
|
||||
/** Kubernetes extended resource names for Intel GPU */
|
||||
export const INTEL_GPU_RESOURCE = 'gpu.intel.com/i915' as const;
|
||||
export const INTEL_GPU_XE_RESOURCE = 'gpu.intel.com/xe' as const;
|
||||
export const INTEL_GPU_MILLICORES_RESOURCE = 'gpu.intel.com/millicores' as const;
|
||||
export const INTEL_GPU_MEMORY_RESOURCE = 'gpu.intel.com/memory.max' as const;
|
||||
|
||||
/** All Intel GPU resource names (prefix match) */
|
||||
export const INTEL_GPU_RESOURCE_PREFIX = 'gpu.intel.com/';
|
||||
|
||||
/** Node labels set by Intel Node Feature Discovery */
|
||||
export const INTEL_GPU_NODE_LABEL = 'intel.feature.node.kubernetes.io/gpu';
|
||||
export const INTEL_DISCRETE_GPU_NODE_ROLE = 'node-role.kubernetes.io/gpu';
|
||||
export const INTEL_INTEGRATED_GPU_NODE_ROLE = 'node-role.kubernetes.io/igpu';
|
||||
|
||||
/** Label selector for Intel GPU device plugin DaemonSet pods */
|
||||
export const INTEL_GPU_PLUGIN_LABEL_SELECTOR =
|
||||
'app=intel-gpu-plugin';
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Generic Kubernetes object base shapes
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export interface KubeObjectMeta {
|
||||
name: string;
|
||||
namespace?: string;
|
||||
creationTimestamp?: string;
|
||||
labels?: Record<string, string>;
|
||||
annotations?: Record<string, string>;
|
||||
uid?: string;
|
||||
}
|
||||
|
||||
export interface KubeObject {
|
||||
apiVersion?: string;
|
||||
kind?: string;
|
||||
metadata: KubeObjectMeta;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// GpuDevicePlugin CRD (deviceplugin.intel.com/v1)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export interface GpuDevicePluginSpec {
|
||||
image?: string;
|
||||
sharedDevNum?: number;
|
||||
enableMonitoring?: boolean;
|
||||
preferredAllocationPolicy?: string;
|
||||
nodeSelector?: Record<string, string>;
|
||||
resourceManager?: boolean;
|
||||
logLevel?: number;
|
||||
}
|
||||
|
||||
export interface GpuDevicePluginStatus {
|
||||
/** Number of nodes where the plugin daemonset is scheduled */
|
||||
desiredNumberScheduled?: number;
|
||||
/** Number of nodes where the plugin daemonset is running and ready */
|
||||
numberReady?: number;
|
||||
/** Number of nodes where the plugin daemonset pod is unavailable */
|
||||
numberUnavailable?: number;
|
||||
/** Number of nodes where the plugin daemonset is available */
|
||||
numberAvailable?: number;
|
||||
}
|
||||
|
||||
export interface GpuDevicePlugin extends KubeObject {
|
||||
spec: GpuDevicePluginSpec;
|
||||
status?: GpuDevicePluginStatus;
|
||||
}
|
||||
|
||||
export function isGpuDevicePlugin(value: unknown): value is GpuDevicePlugin {
|
||||
if (!value || typeof value !== 'object') return false;
|
||||
const obj = value as Record<string, unknown>;
|
||||
return obj['kind'] === 'GpuDevicePlugin';
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Node (with GPU resource fields)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export interface NodeResources {
|
||||
[key: string]: string | undefined;
|
||||
}
|
||||
|
||||
export interface NodeStatus {
|
||||
capacity?: NodeResources;
|
||||
allocatable?: NodeResources;
|
||||
conditions?: Array<{
|
||||
type: string;
|
||||
status: string;
|
||||
lastHeartbeatTime?: string;
|
||||
reason?: string;
|
||||
message?: string;
|
||||
}>;
|
||||
nodeInfo?: {
|
||||
kernelVersion?: string;
|
||||
osImage?: string;
|
||||
architecture?: string;
|
||||
kubeletVersion?: string;
|
||||
};
|
||||
}
|
||||
|
||||
export interface NodeSpec {
|
||||
taints?: Array<{ key: string; effect: string; value?: string }>;
|
||||
unschedulable?: boolean;
|
||||
}
|
||||
|
||||
export interface IntelGpuNode extends KubeObject {
|
||||
spec?: NodeSpec;
|
||||
status?: NodeStatus;
|
||||
}
|
||||
|
||||
/** Returns true if the node has any Intel GPU resources in its capacity */
|
||||
export function isIntelGpuNode(node: unknown): node is IntelGpuNode {
|
||||
if (!node || typeof node !== 'object') return false;
|
||||
const obj = node as Record<string, unknown>;
|
||||
const meta = obj['metadata'] as Record<string, unknown> | undefined;
|
||||
const labels = meta?.['labels'] as Record<string, string> | undefined;
|
||||
const status = obj['status'] as Record<string, unknown> | undefined;
|
||||
const capacity = status?.['capacity'] as Record<string, string> | undefined;
|
||||
|
||||
// Check node labels (added by Intel Node Feature Discovery)
|
||||
if (labels) {
|
||||
if (
|
||||
labels[INTEL_GPU_NODE_LABEL] === 'true' ||
|
||||
labels[INTEL_DISCRETE_GPU_NODE_ROLE] === 'true' ||
|
||||
labels[INTEL_INTEGRATED_GPU_NODE_ROLE] === 'true'
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
// Check node capacity for Intel GPU resources
|
||||
if (capacity) {
|
||||
for (const key of Object.keys(capacity)) {
|
||||
if (key.startsWith(INTEL_GPU_RESOURCE_PREFIX)) return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
export function filterIntelGpuNodes(items: unknown[]): IntelGpuNode[] {
|
||||
return items.filter(isIntelGpuNode);
|
||||
}
|
||||
|
||||
/** Get all Intel GPU resource entries from a node's capacity/allocatable */
|
||||
export function getGpuResources(resources: NodeResources | undefined): Record<string, string> {
|
||||
if (!resources) return {};
|
||||
const gpuResources: Record<string, string> = {};
|
||||
for (const [key, value] of Object.entries(resources)) {
|
||||
if (key.startsWith(INTEL_GPU_RESOURCE_PREFIX) && value !== undefined) {
|
||||
gpuResources[key] = value;
|
||||
}
|
||||
}
|
||||
return gpuResources;
|
||||
}
|
||||
|
||||
/** Get total GPU count from node capacity */
|
||||
export function getNodeGpuCount(node: IntelGpuNode): number {
|
||||
const capacity = node.status?.capacity ?? {};
|
||||
let count = 0;
|
||||
for (const [key, value] of Object.entries(capacity)) {
|
||||
if ((key === INTEL_GPU_RESOURCE || key === INTEL_GPU_XE_RESOURCE) && value) {
|
||||
count += parseInt(value, 10) || 0;
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
/** Determine GPU type from node labels */
|
||||
export type GpuType = 'discrete' | 'integrated' | 'unknown';
|
||||
|
||||
export function getNodeGpuType(node: IntelGpuNode): GpuType {
|
||||
const labels = node.metadata.labels ?? {};
|
||||
if (labels[INTEL_DISCRETE_GPU_NODE_ROLE] === 'true') return 'discrete';
|
||||
if (labels[INTEL_INTEGRATED_GPU_NODE_ROLE] === 'true') return 'integrated';
|
||||
// Fallback: check for generic Intel GPU label
|
||||
if (labels[INTEL_GPU_NODE_LABEL] === 'true') return 'unknown';
|
||||
return 'unknown';
|
||||
}
|
||||
|
||||
export function formatGpuType(type: GpuType): string {
|
||||
switch (type) {
|
||||
case 'discrete': return 'Discrete';
|
||||
case 'integrated': return 'Integrated';
|
||||
default: return 'Unknown';
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Pod (with GPU resource requests)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export interface ResourceRequirements {
|
||||
requests?: Record<string, string>;
|
||||
limits?: Record<string, string>;
|
||||
}
|
||||
|
||||
export interface ContainerSpec {
|
||||
name: string;
|
||||
image?: string;
|
||||
resources?: ResourceRequirements;
|
||||
}
|
||||
|
||||
export interface ContainerStatus {
|
||||
name: string;
|
||||
ready: boolean;
|
||||
restartCount: number;
|
||||
image?: string;
|
||||
state?: {
|
||||
running?: { startedAt?: string };
|
||||
waiting?: { reason?: string; message?: string };
|
||||
terminated?: { exitCode?: number; reason?: string };
|
||||
};
|
||||
}
|
||||
|
||||
export interface PodSpec {
|
||||
nodeName?: string;
|
||||
containers?: ContainerSpec[];
|
||||
initContainers?: ContainerSpec[];
|
||||
}
|
||||
|
||||
export interface PodStatus {
|
||||
phase?: string;
|
||||
conditions?: Array<{ type: string; status: string }>;
|
||||
containerStatuses?: ContainerStatus[];
|
||||
}
|
||||
|
||||
export interface IntelGpuPod extends KubeObject {
|
||||
spec?: PodSpec;
|
||||
status?: PodStatus;
|
||||
}
|
||||
|
||||
/** Returns true if any container in the pod requests Intel GPU resources */
|
||||
export function isGpuRequestingPod(pod: unknown): pod is IntelGpuPod {
|
||||
if (!pod || typeof pod !== 'object') return false;
|
||||
const obj = pod as Record<string, unknown>;
|
||||
const spec = obj['spec'] as Record<string, unknown> | undefined;
|
||||
const containers = (spec?.['containers'] ?? []) as ContainerSpec[];
|
||||
const initContainers = (spec?.['initContainers'] ?? []) as ContainerSpec[];
|
||||
|
||||
return [...containers, ...initContainers].some(c => {
|
||||
const requests = c.resources?.requests ?? {};
|
||||
const limits = c.resources?.limits ?? {};
|
||||
return Object.keys({ ...requests, ...limits }).some(k =>
|
||||
k.startsWith(INTEL_GPU_RESOURCE_PREFIX)
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
export function filterGpuRequestingPods(items: unknown[]): IntelGpuPod[] {
|
||||
return items.filter(isGpuRequestingPod);
|
||||
}
|
||||
|
||||
/** Returns true if any container in the pod requests Intel GPU resources (for plugin pods) */
|
||||
export function isIntelGpuPluginPod(pod: unknown): pod is IntelGpuPod {
|
||||
if (!pod || typeof pod !== 'object') return false;
|
||||
const obj = pod as Record<string, unknown>;
|
||||
const meta = obj['metadata'] as Record<string, unknown> | undefined;
|
||||
const labels = meta?.['labels'] as Record<string, string> | undefined;
|
||||
if (!labels) return false;
|
||||
return labels['app'] === 'intel-gpu-plugin' ||
|
||||
(labels['app.kubernetes.io/name'] === 'intel-gpu-plugin') ||
|
||||
(labels['component'] === 'intel-gpu-plugin');
|
||||
}
|
||||
|
||||
export function filterIntelGpuPluginPods(items: unknown[]): IntelGpuPod[] {
|
||||
return items.filter(isIntelGpuPluginPod);
|
||||
}
|
||||
|
||||
/** Get total GPU requests from a pod's containers */
|
||||
export function getPodGpuRequests(pod: IntelGpuPod): Record<string, string> {
|
||||
const totals: Record<string, number> = {};
|
||||
const allContainers = [
|
||||
...(pod.spec?.containers ?? []),
|
||||
...(pod.spec?.initContainers ?? []),
|
||||
];
|
||||
for (const c of allContainers) {
|
||||
const requests = c.resources?.requests ?? {};
|
||||
for (const [key, value] of Object.entries(requests)) {
|
||||
if (key.startsWith(INTEL_GPU_RESOURCE_PREFIX) && value) {
|
||||
totals[key] = (totals[key] ?? 0) + (parseInt(value, 10) || 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
return Object.fromEntries(Object.entries(totals).map(([k, v]) => [k, String(v)]));
|
||||
}
|
||||
|
||||
export function isPodReady(pod: IntelGpuPod): boolean {
|
||||
return (
|
||||
pod.status?.conditions?.some(c => c.type === 'Ready' && c.status === 'True') ?? false
|
||||
);
|
||||
}
|
||||
|
||||
export function getPodRestarts(pod: IntelGpuPod): number {
|
||||
return (
|
||||
pod.status?.containerStatuses?.reduce((sum, c) => sum + c.restartCount, 0) ?? 0
|
||||
);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// K8s API list response envelope
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export interface KubeList<T> {
|
||||
items: T[];
|
||||
metadata?: { resourceVersion?: string };
|
||||
}
|
||||
|
||||
export function isKubeList(value: unknown): value is KubeList<unknown> {
|
||||
if (!value || typeof value !== 'object') return false;
|
||||
return Array.isArray((value as Record<string, unknown>)['items']);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Node condition helpers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export function isNodeReady(node: IntelGpuNode): boolean {
|
||||
return (
|
||||
node.status?.conditions?.some(c => c.type === 'Ready' && c.status === 'True') ?? false
|
||||
);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Utility: human-readable age
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export function formatAge(timestamp: string | undefined): string {
|
||||
if (!timestamp) return 'unknown';
|
||||
const diffMs = Date.now() - new Date(timestamp).getTime();
|
||||
const secs = Math.floor(diffMs / 1000);
|
||||
if (secs < 60) return `${secs}s`;
|
||||
const mins = Math.floor(secs / 60);
|
||||
if (mins < 60) return `${mins}m`;
|
||||
const hours = Math.floor(mins / 60);
|
||||
if (hours < 24) return `${hours}h`;
|
||||
const days = Math.floor(hours / 24);
|
||||
return `${days}d`;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Utility: GPU resource display name
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export function formatGpuResourceName(resourceKey: string): string {
|
||||
const name = resourceKey.replace(INTEL_GPU_RESOURCE_PREFIX, '');
|
||||
const map: Record<string, string> = {
|
||||
'i915': 'GPU (i915)',
|
||||
'xe': 'GPU (Xe)',
|
||||
'millicores': 'GPU Millicores',
|
||||
'memory.max': 'GPU Memory (max)',
|
||||
'tiles': 'GPU Tiles',
|
||||
};
|
||||
return map[name] ?? name;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Status helpers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export function pluginStatusToStatus(
|
||||
plugin: GpuDevicePlugin
|
||||
): 'success' | 'warning' | 'error' {
|
||||
const desired = plugin.status?.desiredNumberScheduled ?? 0;
|
||||
const ready = plugin.status?.numberReady ?? 0;
|
||||
const unavailable = plugin.status?.numberUnavailable ?? 0;
|
||||
|
||||
if (desired === 0) return 'warning';
|
||||
if (unavailable > 0) return 'warning';
|
||||
if (ready === desired) return 'success';
|
||||
return 'error';
|
||||
}
|
||||
|
||||
export function pluginStatusText(plugin: GpuDevicePlugin): string {
|
||||
const desired = plugin.status?.desiredNumberScheduled ?? 0;
|
||||
const ready = plugin.status?.numberReady ?? 0;
|
||||
if (desired === 0) return 'No nodes scheduled';
|
||||
return `${ready}/${desired} ready`;
|
||||
}
|
||||
Reference in New Issue
Block a user