apiVersion: resource.k8s.io/v1beta2
kind: ResourceSlice
metadata:
name: prod-gpu-07-devices
ownerReferences:
    - apiVersion: v1
    kind: Node
    name: prod-gpu-07
spec:
driver: gpu.nvidia.com
devices:
    # GPU funcional sin taints
    - name: "gpu-0"
    capacity:
        memory: "80Gi"

    # GPU faulty con taint NoSchedule
    - name: "gpu-3"
    capacity:
        memory: "80Gi"
    taints:
        - key: "hardware"
        value: "faulty"
        effect: "NoSchedule"
        # Timestamp cuando detectamos el problema
        timeAdded: "2025-12-23T10:30:00Z"

# DeviceClass para GPUs con compliance requirements
apiVersion: resource.k8s.io/v1beta2
kind: DeviceClass
metadata:
name: nvidia-h100-soc2-certified
spec:
driver: gpu.nvidia.com
# Selector filtra solo nodos certificados
selectors:
    - cel:
        expression: 'node.labels["compliance/soc2"] == "true"'
# Config específica para GPUs compliance
config:
    - opaque:
        driver: gpu.nvidia.com
        parameters:
        # Encryption at rest obligatorio
        encryptionEnabled: true
        # Audit logging detallado
        auditLevel: detailed
        # Memory scrubbing al release
        memoryScrubbing: true

---

# Pod con toleration para GPUs compliance
apiVersion: v1
kind: Pod
metadata:
name: pii-processing-job
namespace: compliance-workloads
labels:
    workload-type: soc2-certified
spec:
containers:
    - name: model-training
    image: private-registry/pii-model:v2.1
    resources:
        claims:
        - name: gpu
resourceClaims:
    - name: gpu
    resourceClaimTemplateName: soc2-gpu-claim-template
# Toleration para device taint compliance
tolerations:
    - key: "compliance"
    operator: "Equal"
    value: "soc2-required"
    effect: "NoSchedule"

apiVersion: v1
kind: Pod
metadata:
name: research-training-job
namespace: ml-research
spec:
containers:
    - name: pytorch-trainer
    image: pytorch/pytorch:2.5.0-cuda12.4
    command: ["python", "train.py"]
    resources:
        claims:
        - name: research-gpu
# ResourceClaim con toleration para device taint
resourceClaims:
    - name: research-gpu
    source:
        resourceClaimTemplateName: research-gpu-claim
    # Tolerations a nivel de device (NO node)
    deviceTolerations:
        - key: "team"
        operator: "Equal"
        value: "research"
        effect: "NoSchedule"
        # Opcional: toleration para GPUs experimental
        - key: "hardware"
        operator: "Equal"
        value: "experimental"
        effect: "NoSchedule"

apiVersion: resource.k8s.io/v1beta2
kind: ResourceClaim
metadata:
name: training-gpu-claim
namespace: ml-workloads
spec:
# DeviceClass que define tipo de GPU
devices:
    requests:
    - name: gpu
        deviceClassName: nvidia-h100-80gb
        # Cantidad de GPUs necesarias
        count: 2
        # Constraints opcionales
        selectors:
        - cel:
            expression: 'device.capacity["memory"] >= 80Gi'
# Topology preferences (prefer mismo nodo)
allocationMode: ExactCount
# Lifecycle: claim persiste después de Pod terminar
controller: training-controller 

#!/bin/bash
# Script verificación K8s 1.33 DRA prerequisites

echo "=== Verificando Kubernetes version ==="
kubectl version --short

echo "=== Verificando feature gates kube-apiserver ==="
kubectl get --raw /api/v1 | jq '.resources[] | select(.name == "resourceslices")'

echo "=== Verificando GPU nodes disponibles ==="
kubectl get nodes -o json | jq '.items[] | select(.status.allocatable["nvidia.com/gpu"] != null) | {name: .metadata.name, gpus: .status.allocatable["nvidia.com/gpu"]}'

echo "=== Verificando API v1beta2 disponible ==="
kubectl api-resources | grep resourceclaims

# Expected output si todo OK:
# resourceclaims                resource.k8s.io/v1beta2        true         ResourceClaim
# resourceclaimtemplates        resource.k8s.io/v1beta2        true         ResourceClaimTemplate
# deviceclasses                 resource.k8s.io/v1beta2        false        DeviceClass
# resourceslices                resource.k8s.io/v1beta2        false        ResourceSlice

# Añadir Helm repo NVIDIA
helm repo add nvidia https://helm.ngc.nvidia.com/nvidia
helm repo update

# Install DRA driver como DaemonSet
helm install nvidia-dra-driver nvidia/k8s-dra-driver \
--namespace kube-system \
--set image.repository=nvcr.io/nvidia/cloud-native/k8s-dra-driver \
--set image.tag=v0.3.0 \
--set driver.name=gpu.nvidia.com \
--set enableDeviceDiscovery=true \
--set enableMIG=true \
--set enableGPUDirect=false

# Verificar DaemonSet running
kubectl get daemonset -n kube-system nvidia-dra-driver
kubectl get pods -n kube-system -l app=nvidia-dra-driver

# Expected output:
# NAME                    READY   STATUS    RESTARTS   AGE
# nvidia-dra-driver-x     1/1     Running   0          30s

# Listar todos los ResourceSlices
kubectl get resourceslice

# Expected output:
# NAME                       DRIVER           POOL    DEVICES
# prod-gpu-01-nvidia-gpus    gpu.nvidia.com   pool1   8
# prod-gpu-02-nvidia-gpus    gpu.nvidia.com   pool1   8

# Inspect ResourceSlice detallado
kubectl get resourceslice prod-gpu-01-nvidia-gpus -o yaml

# Campos importantes a verificar:
# - spec.driver: "gpu.nvidia.com"
# - spec.devices[].name: "gpu-0", "gpu-1", etc.
# - spec.devices[].capacity.memory: "80Gi" (para H100)
# - spec.devices[].attributes: vendor, model, architecture

# Verificar driver logs si ResourceSlices no aparecen
kubectl logs -n kube-system daemonset/nvidia-dra-driver --tail=50

apiVersion: batch/v1
kind: Job
metadata:
name: llm-training-70b
namespace: ml-training
spec:
# Gang scheduling con suspend hasta todas replicas ready
parallelism: 4
completions: 4
suspend: false
template:
    metadata:
    labels:
        app: llm-training
        gang-name: training-group-1
    spec:
    # Affinity: prefer GPUs en mismo nodo
    affinity:
        podAffinity:
        preferredDuringSchedulingIgnoredDuringExecution:
            - weight: 100
            podAffinityTerm:
                labelSelector:
                matchLabels:
                    gang-name: training-group-1
                topologyKey: kubernetes.io/hostname
    containers:
        - name: trainer
        image: nvcr.io/nvidia/pytorch:24.12-py3
        command:
            - torchrun
            - "--nnodes=4"
            - "--nproc_per_node=8"
            - "train_llm.py"
        resources:
            claims:
            - name: gpu
            requests:
            cpu: "32"
            memory: "256Gi"
    resourceClaims:
        - name: gpu
        source:
            resourceClaimName: training-gpu-claim

---

apiVersion: resource.k8s.io/v1beta2
kind: ResourceClaim
metadata:
name: training-gpu-claim
namespace: ml-training
spec:
devices:
    requests:
    - name: gpu
        deviceClassName: nvidia-h100-80gb
        count: 8  # 8 GPUs por Pod × 4 Pods = 32 GPUs total
# Topology constraint: prefer mismo nodo
allocationMode: ExactCount
selectors:
    - cel:
        expression: 'device.attributes["nvlink"] == "true"'

# DeviceClass para MIG partitions de 10GB
apiVersion: resource.k8s.io/v1beta2
kind: DeviceClass
metadata:
name: nvidia-h100-mig-1g-10gb
spec:
driver: gpu.nvidia.com
config:
    - opaque:
        driver: gpu.nvidia.com
        parameters:
        # MIG profile específico
        migProfile: "1g.10gb"
        # Compute instance size
        computeInstance: "1"

---

# ResourceClaim para inference model
apiVersion: resource.k8s.io/v1beta2
kind: ResourceClaim
metadata:
name: recommendation-model-gpu
namespace: ml-inference
spec:
devices:
    requests:
    - name: gpu-partition
        deviceClassName: nvidia-h100-mig-1g-10gb
        # Solo necesita 1 partition (10GB)
        count: 1
        # Constraint: mínimo 8GB disponibles
        selectors:
        - cel:
            expression: 'device.capacity["memory"] >= 8Gi'

---

# Deployment usando GPU partition
apiVersion: apps/v1
kind: Deployment
metadata:
name: recommendation-inference
namespace: ml-inference
spec:
replicas: 3
selector:
    matchLabels:
    app: recommendation
template:
    metadata:
    labels:
        app: recommendation
    spec:
    containers:
        - name: triton-server
        image: nvcr.io/nvidia/tritonserver:24.12-py3
        resources:
            claims:
            - name: gpu
        env:
            - name: MODEL_REPOSITORY
            value: /models
    resourceClaims:
        - name: gpu
        source:
            resourceClaimName: recommendation-model-gpu

#!/bin/bash
POD_NAME=$1
NAMESPACE=$2

echo "=== Checking Pod events ==="
kubectl describe pod $POD_NAME -n $NAMESPACE | grep -A 20 Events

echo "=== Checking ResourceClaim status ==="
CLAIM_NAME=$(kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath='{.spec.resourceClaims[0].name}')
kubectl get resourceclaim $CLAIM_NAME -n $NAMESPACE -o yaml

echo "=== Checking ResourceSlices availability ==="
kubectl get resourceslice -o json | jq '.items[] | {name: .metadata.name, devices: .spec.devices | length}'

echo "=== Checking scheduler logs for this Pod ==="
kubectl logs -n kube-system $(kubectl get pods -n kube-system -l component=kube-scheduler -o name) --tail=100 | grep $POD_NAME