Jobplanung für KI-Cluster: SLURM, Kubernetes, Ray und wann man keines davon braucht.
Ein Scheduler legt fest, welcher Job wann auf welchen GPUs und auf wessen Kosten ausgeführt wird. Ohne einen solchen Scheduler verkommt ein gemeinsam genutzter Cluster zu einem unübersichtlichen Netzwerk, in dem sich die Entwickler ständig über Slack fragen, ob jemand Knoten 3 nutzt. Mit dem falschen Scheduler verbringen die Entwickler mehr Zeit mit YAML-Dateien als mit der eigentlichen Modellierung.
Dieser Artikel vergleicht die tatsächlich verwendeten Scheduler – SLURM, Kubernetes (mit Kueue oder Volcano), Ray und KubeRay sowie die kommerziellen Optionen Run:ai und Determined – und geht ehrlich auf den Fall ein, in dem die richtige Antwort „nichts, nur SSH“ lautet. Die Leser haben K01 , K02 und K03 gelesen und entscheiden nun, welche Technologie sie auf einem Cluster mit 1–32 Knoten einsetzen möchten.
Was ein Terminplaner tatsächlich tut
Drei Aufgaben, grob geordnet nach Schwierigkeitsgrad: Arbeit auf freien Ressourcen platzieren, Arbeit, die noch nicht passt, in die Warteschlange stellen und Multi-Node-Jobs koordinieren – verteiltes Training erfordert, dass alle N Ränge gleichzeitig starten (Gangplanung), weil ein PyTorch dist.barrier() Blockiert auf unbestimmte Zeit, wenn ein Rang nie auftaucht (siehe K06).
Alles, was über einen Cluster mit einem einzelnen Team hinausgeht, benötigt außerdem Multi-Tenant-Quoten mit Ausleihe, fairer Verteilung über Teams hinweg, Präemption und korrekter GPU-Abrechnung (damit der Job sieht, CUDA_VISIBLE_DEVICES (richtig konfiguriert). Alle unten aufgeführten Scheduler erfüllen die ersten drei Punkte. Die Unterschiede liegen in der zweiten Liste und der Art der Arbeit, die sie voraussetzen.
Der große Unterschied: Stapelverarbeitung vs. langlaufende Dienste
Dies ist der mit Abstand wichtigste Aspekt. Batch-Jobs laufen acht Stunden lang und werden dann beendet, oder sie führen einen Hyperparameter-Sweep von 200 kurzen Jobs durch, oder sie verarbeiten einen Datensatz über Nacht – Start, Ende, Ergebnis, aber keine Antwort auf HTTP-Anfragen. Langlaufende Dienste sind beispielsweise ein vLLM-Endpunkt, der rund um die Uhr Inferenzdaten liefert, eine Szenenspeicherdatenbank und ein Überwachungssystem – diese sollen dauerhaft verfügbar sein und bei einem Absturz neu starten.
SLURM wurde für Batch-Verarbeitung entwickelt. Kubernetes wurde für langlaufende Dienste entwickelt. Alles andere ist im Grunde nur eines der beiden, das erweitert wird, um auch die jeweils andere Hälfte abzudecken.
| Arbeitsbelastung | SCHLAMM | Kubernetes |
|---|---|---|
| 8-stündiger Trainingslauf | Ureinwohner | Benötigt Kueue oder Vulkan |
| Hyperparameter-Sweep für 200 Jobs | Ureinwohner | Umständlich |
| 24/7 vLLM-Inferenzendpunkt | Umständlich | Ureinwohner |
| Gemischt: Training + Inferenz + Werkzeuge | Schmerzlich | Native (mit Kueue) |
| Verteiltes Training auf mehreren Knoten | Einheimischer (Gang) | Benötigt Gang-Plugin |
| Automatischer Neustart abgestürzter Dienste | Nein | Ureinwohner |
Wenn Ihr Cluster nur eine dieser Aufgaben erfüllt, ist die Wahl einfach. Wenn er beides erfüllt – was immer häufiger vorkommt –, stellt sich die Frage, für welchen Scheduler Sie die zusätzlichen Betriebskosten tragen möchten.
SLURM – der HPC-Standard, der für reines Training immer noch unübertroffen ist
SLURM ist auf über 65 % der TOP500-Supercomputer und den meisten veröffentlichten Trainingsläufen für Spitzentechnologie im Einsatz. Für Arbeitslasten, die sich in etwa so darstellen lassen wie „Trainingsauftrag einreichen, auf Ergebnisse warten, Checkpoint abrufen“, ist es seit zwanzig Jahren die optimale Lösung.
Das mentale Modell ist einfach: a Trennwand ist ein benannter Pool von Knoten (gpu-5090, cpu-only, bigmem); A Job ist ein Shell-Skript mit #SBATCH Richtlinien, eingereicht mit sbatch; GRES (Generische Ressourcen) verfolgt GPUs — --gres=gpu:rtxpro6000:2 verlangt zwei bestimmte Karten; Gangplanung ist eingebaut.
Ein minimales slurm.conf für einen 4-Knoten-Cluster mit 8× RTX Pro 6000 Blackwell pro Knoten:
ClusterName=kentino-lab
SlurmctldHost=head01
SchedulerType=sched/backfill
SelectType=select/cons_tres
SelectTypeParameters=CR_Core_Memory
GresTypes=gpu
# GPU accounting — without these two lines, fair-share runs on CPU-seconds and is meaningless
AccountingStorageType=accounting_storage/slurmdbd
AccountingStorageTRES=gres/gpu
PriorityType=priority/multifactor
PriorityDecayHalfLife=7-0
PriorityWeightFairshare=10000
PriorityWeightAge=1000
# cgroups isolate the GPUs a job is allowed to see
ProctrackType=proctrack/cgroup
NodeName=node[01-04] CPUs=128 RealMemory=1024000 Sockets=2 \
CoresPerSocket=64 ThreadsPerCore=1 Gres=gpu:rtxpro6000:8 State=UNKNOWN
PartitionName=train Nodes=node[01-03] Default=YES MaxTime=48:00:00 State=UP
PartitionName=interactive Nodes=node04 MaxTime=04:00:00 \
PriorityTier=10 State=UP
Das Matching gres.conf auf jedem Knoten:
AutoDetect=nvml
NodeName=node[01-04] Name=gpu Type=rtxpro6000 File=/dev/nvidia[0-7]
AutoDetect=nvml Fragt die NVIDIA Management Library direkt ab, erkennt MIG-Slices automatisch und erspart Ihnen das manuelle Erstellen von Gerätedateipfaden.
Ein Benutzer reicht Folgendes ein:
#!/bin/bash
#SBATCH --job-name=qwen-finetune
#SBATCH --partition=train
#SBATCH --nodes=2
#SBATCH --ntasks-per-node=8
#SBATCH --gres=gpu:rtxpro6000:8
#SBATCH --time=12:00:00
#SBATCH --output=logs/%j.out
srun python -m torch.distributed.run \
--nnodes=2 --nproc-per-node=8 \
--rdzv-backend=c10d \
--rdzv-endpoint=$(scontrol show hostnames | head -1):29500 \
train.py --config configs/qwen72b.yaml
PyTorch Elastic und SLURM lassen sich nahtlos kombinieren: SLURM verwaltet die Ressourcen, srun startet einen Prozess pro Aufgabe. torch.distributed.run Zusätzlich übernimmt das Rendezvous-Backend die Rangzuweisung. Bei einem Knotenausfall --max-restarts on torchrun erfahren --requeue on #SBATCH Stellt die Leistung vom letzten Kontrollpunkt wieder her. Alle machen es so.
Was Sie kostenlos erhalten: Gruppenplanung, fairer Ressourcenverfall, Backfill, Abrechnung (jede GPU-Sekunde wird protokolliert). sacctSLURM zeichnet sich durch einfache Semantik aus – keine CRDs, kein Controller, kein YAML-Objektgraph. Was Sie nicht erhalten: langlebige Dienste mit automatischem Neustart, HTTP-Ingress, Rolling Updates, Sidecar-Container, deklarativer Zustand. SLURM ist ein Batch-Scheduler. Ihn wie Kubernetes zu behandeln, führt zu Problemen.
SLURM ist genau das Richtige, wenn: Sie Training, Batch-Inferenz oder Simulation durchführen; Benutzer Shell-Skripte schreiben; ein Teilzeit-SRE es bedienen kann.
Wo SLURM an seine Grenzen stößt
Drei Plätze. Webbasierte Dienste — kein Konzept von „dauerhaft laufen, bei Tod neu starten, Port 8000 freigeben“. Man kann vLLM zwar in einen langlaufenden SLURM-Job einbauen, aber dann werden Zustandsprüfungen, rollierende Updates und Lastverteilung zum Problem. Heterogene Arbeitslasten — SLURM geht von einem einzigen Ressourcenpool aus; ein Cluster, der Training + Inferenz + Jupyter + Monitoring + Datenaufbereitung ausführt, benötigt feinere Steuerungsmöglichkeiten. Strenge Trennung mehrerer Mieter — cgroups isolieren CPU und Speicher; die GPU-Isolation basiert auf CUDA_VISIBLE_DEVICES und der Benutzercode muss dies berücksichtigen. Keine Namensräume, keine netzwerkbasierte Richtlinie pro Auftrag, keine Mandantenfähigkeit auf Containerebene. Für Testumgebungen geeignet; nicht für einen gehosteten Dienst für mehrere Kunden.
Wenn Sie auf eines dieser Probleme stoßen, ist es meist ratsam, eine zweite Ebene – Kubernetes für die Dienste – hinzuzufügen, anstatt SLURM zu überlasten. Die Managed-Lösungen SUNK und 2026 von CoreWeave nutzen SLURM auf Kubernetes, sodass derselbe Cluster beides übernimmt. Bei Kentino-Umgebungen sind zwei separate, kleine Cluster oft einfacher.
Kubernetes für KI: der Cloud-native Weg
Kubernetes wurde entwickelt, um zustandslose Webdienste zu betreiben. Für KI-Cluster wird „alles andere“ hinzugefügt. Der Stack von 2026: NVIDIA GPU Operator (Treiber, CUDA, NCCL, DCGM, Geräte-Plugin, MIG-Konfiguration), Kueue (Warteschlange, Kontingent, Zulassung), Volcano (Batch-fähiger Scheduler), Kubeflow Trainer (PyTorchJob, TFJob, MPIJob CRDs), KubeRay (Ray auf Kubernetes) und Karpenter oder Cluster Autoscaler für die Knotenbereitstellung.
Warum naives Kubernetes für KI ungeeignet ist: Der standardmäßige kube-scheduler arbeitet nach dem FIFO-Prinzip ohne Gruppenstruktur. Er startet gerne 7 von 8 Pods eines verteilten Trainingsjobs und lässt den achten im Status „Ausstehend“, während die laufenden 7 die GPUs im Leerlauf belegen. Dies ist keine Theorie – es ist der häufigste Fehler, den Teams begehen, wenn sie versuchen, Training auf einem Cluster durchzuführen, den sie für Inferenz erstellt haben. Die Lösungen sind Kueue (Job-basierte Zulassung) und Volcano (Pod-basierte Gruppenstrukturierung). Aktuell empfiehlt sich die Kombination beider Methoden: Kueue oben, Volcano unten.
Vulkan
Volcano ist ein CNCF-Batch-Scheduler, der parallel zu oder anstelle von kube-scheduler installiert wird. Er fügt echtes Gang-Scheduling hinzu. minAvailable Semantik (Null oder N zulassen, niemals Teilmengen), Warteschlangenprioritäten und Präemption, Fair-Share-/Binpack-/Topologie-bewusste Strategien und erstklassige Unterstützung für PyTorchJob, TFJob, MPIJob, RayJob und SparkApplication.
Eine minimale Warteschlange plus ein gemeinsam geplanter PyTorch-Trainingsjob:
apiVersion: scheduling.volcano.sh/v1beta1
kind: Queue
metadata:
name: training
spec:
weight: 4
capability:
nvidia.com/gpu: 32
---
apiVersion: batch.volcano.sh/v1alpha1
kind: Job
metadata:
name: qwen-finetune
spec:
schedulerName: volcano
minAvailable: 16 # gang: all 16 ranks or zero
queue: training
policies:
- event: PodEvicted
action: RestartJob
tasks:
- replicas: 16
name: worker
template:
spec:
containers:
- name: pytorch
image: kentino/pytorch:2.5-cuda13
resources:
limits:
nvidia.com/gpu: 1
command: ["torchrun", "--nnodes=16", "--nproc-per-node=1", "train.py"]
Wenn Sie Volcano nicht benötigen: Ein reiner Inferenzcluster mit unabhängigen vLLM-Deployments. Jeder Pod verwaltet seine eigenen GPUs, es findet keine Pod-übergreifende Koordination statt, und der Standard-kube-scheduler ist ausreichend. Volcano macht sich erst dann bemerkbar, wenn verteiltes Training in den Cluster integriert wird.
Kueue- und Quotenkredite
Kueue bietet eine Funktion, die Volcano nicht bietet: die Frage, wer wie viel vom Cluster verbrauchen darf und was passiert, wenn ein Team im Leerlauf ist.
apiVersion: kueue.x-k8s.io/v1beta1
kind: ResourceFlavor
metadata:
name: rtxpro6000
spec:
nodeLabels:
nvidia.com/gpu.product: "RTX-PRO-6000-Blackwell"
---
apiVersion: kueue.x-k8s.io/v1beta1
kind: ClusterQueue
metadata:
name: team-research
spec:
cohort: "shared-gpu"
resourceGroups:
- coveredResources: ["nvidia.com/gpu"]
flavors:
- name: rtxpro6000
resources:
- name: "nvidia.com/gpu"
nominalQuota: 16
borrowingLimit: 8
Beide Teams der Kohorte erhalten garantiert 16 GPUs und können bis zu 8 weitere aus dem freien GPU-Pool des jeweils anderen Teams ausleihen. Aufgaben mit hoher Priorität haben Vorrang vor der Auslastung der ausgeliehenen Kapazität. Kueue konzentriert sich in seiner Roadmap für 2026 auf MultiKueue (Multi-Cluster-Dispatch) und kooperative Unterbrechung – ein Checkpointing-Job kann beispielsweise angewiesen werden, den Status zu speichern und in 60 Sekunden zu beenden, anstatt sofort abgebrochen zu werden.
MIG- und GPU-Sharing
Das NVIDIA-Geräte-Plugin verwendet standardmäßig die gesamte GPU-Speicherzuweisung. Für Training und umfangreiche Inferenz ist dies korrekt; für kleinere Inferenz, Notebooks oder Entwicklungsarbeiten ist es jedoch ineffizient. Drei Freigabemodi stehen zur Verfügung: MIG (Hardware-Speicher- und Fehlerisolierung, produktive Multi-Tenant-Inferenz), MPS (kooperativ, keine Isolation) und Time-Slicing (keine Isolation, nur für Entwicklung).
MIG ist auf H100/H200, A100 und B200 verfügbar – jedoch nicht auf GPUs der Kentino-Produktpalette. RTX 5090, RTX 4090, RTX Pro 6000 Blackwell, L40 und L4 unterstützen MIG nicht. Falls Ihr Design hardwareisolierte GPU-Partitionen erfordert, sind Sie auf SXM-/Datacenter-Komponenten von Kentino beschränkt, die nicht von Kentino hergestellt werden. Time-Slicing signalisiert N virtuelle GPUs pro physischer GPU, und der Scheduler erkennt eine Überbelegung nicht – verwenden Sie diese Funktion daher nur für Entwicklungszwecke.
Wofür Kubernetes gut geeignet ist: langlaufende Inferenzdienste (vLLM-Bereitstellungen, skaliert durch HPA basierend auf der Warteschlangenlänge, Rolling Updates, Health Checks – SLURM bietet nichts Vergleichbares), heterogene Workloads auf einem Cluster, Ökosystem (Prometheus, Grafana, Argo). Der Aufwand: Ein funktionierender K8s-Stack mit GPU-Operator, Kueue, Volcano und Kubeflow besteht aus mindestens 20 Komponenten. Realistische Einschätzung: Kubernetes verursacht beim reinen Batch-Training die 5- bis 10-fache Betriebslast von SLURM .
Kubernetes ist die richtige Wahl, wenn: der Cluster Inferenzdienste parallel zum Training ausführt, Sie über ein Plattformteam verfügen, deklarative Lösungen wichtig sind oder Sie Multi-Cluster-Portabilität benötigen.
Ray und KubeRay – Python-native verteilte Berechnung
Ray ist etwas ganz anderes. Es ist nicht wirklich ein Cluster-Scheduler im Sinne von SLURM/K8s – es ist eine verteilte Python-Laufzeitumgebung, die mit einem Scheduler, einem Objektspeicher und einem Autoscaler ausgeliefert wird. Man schreibt Python mit @ray.remote Die Dekorateure und Ray legen fest, wo die einzelnen Aufgaben erledigt werden sollen.
Rays Einsatzgebiete: Hyperparameter-Optimierung (Ray Tune – Hunderte paralleler Versuche, frühzeitiges Aussortieren ungeeigneter Ergebnisse; der Anwendungsfall, für den Ray entwickelt wurde und der nach wie vor führend ist), Reinforcement Learning (RLlib – Umgebungen und Lernende als Akteure, was sich nahtlos in Ray, aber nur bedingt in SLURM-Batch-Jobs integrieren lässt), verteiltes Training (Ray Train, eine Wrapper-Lösung für PyTorch DDP/FSDP/DeepSpeed), Modellbereitstellung (Ray Serve, nativ in Python, benutzerdefinierte Multi-Modell-Pipelines) und Datenvorverarbeitung (Ray Data). Was Ray nicht ist: ein mandantenfähiger Batch-Scheduler für einen gemeinsam genutzten Cluster. Ray geht davon aus, dass eine Anwendung den Cluster besitzt.
KubeRay ist der Operator, der Ray auf Kubernetes ausführt. Drei CRDs: RayCluster (langlebig), RayJob (Einmalig), RayService (Ray Serve, fortlaufende Aktualisierungen). Ein minimaler RayCluster:
apiVersion: ray.io/v1
kind: RayCluster
metadata:
name: rl-cluster
spec:
rayVersion: '2.55.0'
headGroupSpec:
rayStartParams: { dashboard-host: '0.0.0.0' }
template:
spec:
containers:
- name: ray-head
image: rayproject/ray:2.55.0-py311-cu125
resources:
limits: { cpu: 8, memory: 32Gi }
workerGroupSpecs:
- groupName: gpu-workers
replicas: 4
minReplicas: 0
maxReplicas: 8
rayStartParams: {}
template:
spec:
containers:
- name: ray-worker
image: rayproject/ray:2.55.0-py311-cu125
resources:
limits:
cpu: 16
memory: 128Gi
nvidia.com/gpu: 4
KubeRay skaliert die Worker-Gruppe automatisch zwischen minReplicas und maxReplicas Basierend auf Rays Ansicht der ausstehenden Aufgaben. In Kombination mit Kueue (RayJob + Kueue-Gangplanung ist dokumentiert und funktioniert) erhalten Sie Multi-Tenant-Ray auf einem Multi-Tenant-K8s-Cluster – die Produktionsumgebung, die die meisten Ray-Umgebungen tatsächlich nutzen.
Ray eignet sich besonders für kleine Forschungslabore, in denen eine Person den Cluster verwaltet, Dynamik wichtiger ist als Mandantenfähigkeit und die Arbeitslast stark auf Reinforcement Learning oder Hyperparameter-Suche basiert. Die gängigste Hybridlösung besteht aus SLURM oder Kubernetes als Basisschicht mit Knotenverwaltung und Mandantenfähigkeit; Ray wird innerhalb eines SLURM-Jobs oder eines Kubernetes-Namespace für die Dauer der Arbeitslast eines Benutzers ausgeführt. Installieren Sie Ray nicht als übergeordneten Scheduler.
Run:ai und Determined – die kommerzielle Ebene
Zwei kostenpflichtige Angebote tauchen häufig genug auf, um sie hier zu erwähnen. Beide zielen auf dasselbe Problem ab: K8s + Volcano + Kueue + GPU Operator erfordern viel YAML-Code, und manche Unternehmen kaufen lieber, als selbst zu entwickeln.
NVIDIA Run:ai (übernommen 2024, umbenannt 2025) ist ein K8s-nativer GPU-Scheduler. GPU-Fraktionierung teilt eine einzelne GPU auf Speicherebene zwischen den Arbeitslasten auf — 0.5 GPU Anfragen, dynamische Größenanpassung, Bin-Packing. Run:ai bewährt sich in Unternehmensumgebungen mit mehr als zehn ML-Teams, die um gemeinsam genutzte GPUs konkurrieren. Darunter deckt Kueue + GPU Operator die meisten dieser Bereiche kostenlos ab.
Determined.AI (HPE, 2021) ist eine Plattform für verwaltetes Training – Experimentverfolgung, Hyperparameter-Suche, Checkpoint-Management und verteiltes Training in einem Produkt. Ideal für Forschungsteams, die ein übersichtliches Dashboard benötigen, ohne fünf Tools selbst integrieren zu müssen.
Das Problem mit dem interaktiven Notizbuch
Ein Muster, das fast jeden gemeinsam genutzten GPU-Cluster erfasst: Forscher benötigen für die Entwicklung Zugriff auf GPUs über JupyterHub, und dies muss mit langlaufenden Trainingsprozessen vereinbar sein, die ganze Knoten belegen. Die naive Lösung – eine dedizierte GPU pro Notebook – verschwendet 80 % des Clusters. Die konsequente Lösung – Forschern sbatch alles – treibt sie auf Laptops mit Spielzeugmodellen.
Drei praktikable Muster: SCHLAMM salloc + Jupyter auf der Zuweisung (salloc --gres=gpu:1 --time=4:00:00, einen Jupyter-Server auf dem zugewiesenen Knoten starten, Tunneling; hartes Zeitlimit, GPU korrekt berücksichtigt — sauberste Lösung für einen SLURM-Cluster), Kubernetes + JupyterHub + Kueue (Notebook-Pods werden über eine Warteschlange mit niedriger Priorität abgearbeitet, Trainingsaufträge verdrängen ungenutzte Notebooks), oder Run:ai mit GPU-Fraktionierung (Notebooks erhalten jeweils 0.25 / 0.5 GPU). Egal, für welches Modell Sie sich entscheiden, Legen Sie ein Zeitlimit für interaktive Sitzungen fest. — Ein Notebook ohne Timeout ist eine GPU, die dauerhaft aus dem Cluster entfernt wurde.
Die ehrliche Realität kleiner Teams
Die meisten Online-Anleitungen für Scheduler gehen von einem Cluster mit 256 GPUs und einem Plattformteam aus. Realistisch betrachtet arbeitet ein Kentino-Kunde jedoch eher mit 1–4 Knoten, insgesamt 4–32 GPUs und 2–6 Benutzern, die sich kennen und über Slack abstimmen. Für diese Konfiguration ist kein Scheduler erforderlich.
# user 1
ssh node01
tmux new -s my-training
CUDA_VISIBLE_DEVICES=0,1,2,3 python train.py
# Ctrl-B D to detach
# user 2 — coordinates on Slack first
ssh node01
nvidia-smi # which GPUs are free?
tmux new -s other-training
CUDA_VISIBLE_DEVICES=4,5,6,7 python train.py
Das ist das gesamte Job-Scheduling-System. SLURM amortisiert sich ab etwa 16 GPUs oder 8 Benutzern, je nachdem, was zuerst eintritt. Darunter übersteigt der Betriebsaufwand den Nutzen. Installieren Sie einen Scheduler erst, wenn die menschliche Koordination nicht mehr ausreicht, nicht vorher.
Wenn jedes Werkzeug passt – die Zusammenfassung
| Szenario | Software Empfehlungen |
|---|---|
| 1–2 Knoten, 4–16 GPUs, 2–6 Benutzer, die miteinander kommunizieren | SSH + tmux + nvidia-smi. Kein Scheduler. |
| Forschungslabor, 4–32 Knoten, Batch-Trainingsaufträge | SLURM. Langweilig, bewährt, passt. |
| Inferenzplattform zur Bedienung des Kundenverkehrs | Kubernetes + GPU-Operator. Kein Batch-Scheduler. |
| Gemischter Cluster: Training + Inferenz + Werkzeuge | Kubernetes + Kueue + Volcano + Kubeflow. |
| Schwer verteiltes Python: RL, Hyperparametersuche | Ray (oder KubeRay) auf SLURM oder K8s. |
| Mehr als 10 ML-Teams konkurrieren um GPUs und Budget für Tools. | Run:ai auf Kubernetes. |
| Gemanagte Trainingsversuche + Tracking | Entschlossen.KI. |
| Mehr als 200 GPUs, Multi-Team, Multi-Workload | Föderiert: SLURM für Batch-Verarbeitung, K8s für Dienste. |
Was ist als Nächstes zu tun – der Entscheidungsbaum
Gehen Sie die Schritte der Reihe nach durch. Das erste „Ja“ beendet das Gespräch.
- Weniger als 16 GPUs und weniger als 8 Benutzer, die miteinander kommunizieren? Ja → Nein-Scheduler. Dokumentieren Sie die Konventionen in einer Markdown-Datei. Überprüfen Sie diese erneut, wenn die Koordination nicht mehr funktioniert.
- Läuft auf dem Cluster sowohl langlaufende Inferenzdienste als auch das Training aus? Ja → Kubernetes ist die Basis. Fügen Sie den GPU-Operator, dann Kueue und schließlich Volcano hinzu, falls verteiltes Training relevant ist. Nein → SLURM ist die Basis.
- Verfügen Sie über ein Plattformteam oder ein Budget dafür (0.5–1.0 FTE für sechs Monate, 0.25 FTE im Dauerbetrieb)? Nein → Bleiben Sie unabhängig von der Workload-Mischung bei SLURM. Die K8s-Steuer ist real.
- Mehr als zehn Teams konkurrieren um GPU-Zeit mit strengen Quotenvorgaben? Ja → Run:ai auswerten. Nein → Kueue + Kohorten bringen Sie zu 80 % ans Ziel.
-
Hohe Arbeitsbelastung durch Reinforcement Learning, Hyperparameter-Suche oder verteiltes Python? Ja → Ray (KubeRay auf K8s, oder
salloc+ Ray auf SLURM). Nein → Ray nicht mitmachen. - Hardware MIG-fähig (Rechenzentrumskarten)? Keine Kentino-Produktpalette → Planung der vollständigen GPU-Zuweisung oder des Time-Slicing nur in der Entwicklungsumgebung. Nicht auf MIG ausrichten.
Die meisten Kentino-Gespräche enden bei Schritt 1, 2 oder 3. Der Rest ist Beiwerk.
Begleitartikel: verteiltes Training in K02 , Inferenzcluster in K03 , Clusterspeicher in K04 , Fehlerbehandlung in K06 , die PCIe-Bandbreitenobergrenze in K07.
Dies ist ein Auszug aus dem Kentino Wiki, einer Referenzreihe zu KI-Computing, Robotik und den Systemen, die diese verbinden. Kommentare und Korrekturen sind willkommen unter info@kentino.com.