GPU-Verwaltung: Warum ungenutzte GPUs die neuen am Boden gebliebenen Flugzeuge sind

GPU-Verwaltung: Warum ungenutzte GPUs die neuen geparkten Flugzeuge sind

Betritt man heute ein KI-Labor, sieht man ein vertrautes Bild: Regale voller teurer GPUs, deren Lüfter im Leerlauf sanft summen, während sie auf einen Auftrag warten, der nie kommen wird. Eine Szene, die unheimlich an eine Flotte geparkter Flugzeuge auf dem Rollfeld erinnert – gewaltige Kapitalanlagen, die jede Sekunde ungenutzten Wert verbrennen. Ein Flugzeug, das fliegt, erwirtschaftet Umsatz; ein geparktes Flugzeug verursacht nur Kosten. Dieselbe Logik gilt für GPUs. Dennoch verwalten die meisten Organisationen ihre GPU-Flotten mit der gleichen Raffinesse, mit der eine kleine Fluggesellschaft in den 1980er-Jahren die Wartung ihrer Flugzeuge betrieb: viel Hardware, wenig Telemetrie und keine dynamische Planung.

Dieser Artikel ist ein praxisorientierter Leitfaden zur Lösung dieses Problems. Wir schauen uns an, warum ungenutzte GPUs so teuer sind, welche Werkzeuge Sie zur Messung des Problems benötigen und wie Sie einen schlanken Monitoring- und Scheduler-Stack auf Ihrer eigenen Infrastruktur installieren, konfigurieren und verwenden. Am Ende haben Sie konkrete Befehle, die Ihre GPU-Flotte von einer versunkenen Kostenstelle in eine gemessene, geteilte und effizient genutzte Ressource verwandeln.

Die versteckten Kosten geparkter Silizium

Der Vergleich zwischen ungenutzten GPUs und geparkten Flugzeugen ist keine Übertreibung. Überlegen Sie, was ein moderner KI-Beschleuniger tatsächlich darstellt. Eine High-End-Rechenzentrums-GPU kann mehrere zehntausend Dollar kosten. Stromversorgung, Kühlung und Netzwerkinfrastruktur verdoppeln diese Kosten. Amortisiert man das über einen Hardware-Lebenszyklus von drei Jahren und rechnet Strom und Systemadministration hinzu, ist jede Stunde, die eine GPU ungenutzt herumsteht, eine direkte Belastung Ihres Betriebsbudgets.

Dennoch richtet sich die Aufmerksamkeit der Branche fast ausschließlich auf das *Trainieren großer Modelle*. Der Hugging-Face-Blog, eine der beständigsten Stimmen zum Thema GPU-Infrastruktur, hat wiederholt betont, dass effizientes GPU-Management genauso kritisch ist wie das Modelldesign. Sie haben hervorgehoben, dass die Kluft zwischen theoretischer Spitzenleistung und tatsächlich erreichter Auslastung enorm ist und dass Werkzeuge – nicht Architektur – diese Kluft schließen. Der Blog ist zu einer verlässlichen Referenz für den Wandel der Community hin zu Messung, Teilung und Optimierung jedes verfügbaren Beschleunigers geworden.

Ein geparktes Flugzeug hat zumindest die Ausrede eines Sturms oder einer technischen Inspektion. Eine ungenutzte GPU hat oft gar keine Ausrede. Sie ist ungenutzt, weil eine Warteschlange schlecht konstruiert ist, weil niemand weiß, dass sie frei ist, oder weil ein Entwickler sie „nur für den Fall" reserviert hat und dann Mittagspause gemacht hat. Das Letztere ist der eigentliche Killer. GPU-Reservierung ohne Scheduler ist das Äquivalent zu einem Piloten, der ein Flugzeug auf dem Rollfeld lässt, weil er *vielleicht* später fliegen möchte.

Was „ungenutzt" eigentlich bedeutet

Bevor wir das Problem beheben, müssen wir es messen. Und bei GPUs ist „ungenutzt" ein differenzierterer Begriff, als man denken könnte.

• **SM-Auslastung**: Der Anteil der Takte der Streaming-Multiprozessoren, die tatsächlich Berechnungen durchführen. Eine GPU mit 100 % SM-Auslastung ist theoretisch beschäftigt, könnte aber trotzdem speichergebunden sein.
• **Speicherauslastung**: Der Prozentsatz des verwendeten Gerätespeichers. Hohe Speichernutzung bei geringer SM-Aktivität deutet oft auf schlechtes Batching und einen Auftrag hin, der auf Datenübertragungen wartet.
• **Leistungsaufnahme**: Ein guter Indikator für die Gesamtaktivität. Eine ungenutzte NVIDIA A100 zieht vielleicht 30–50 Watt; eine voll ausgelastete zieht 250–400 Watt.
• **Compute- vs. Copy-Engines**: Wenn die Copy-Engines gesättigt sind, während die Compute-Engines im Leerlauf sind, füttern Sie die GPU zu langsam.

Die Werkzeuge, die wir als Nächstes installieren, zeigen Ihnen all diese Metriken. Nach einer Woche Datenerfassung sehen Sie Ihre eigene „geparkte Flotte" deutlich: vielleicht eine GPU mit 90 % Auslastung und sieben weitere mit 5 %, weil Ihr Scheduler eine Wiki-Seite und ein Gebet war.

Voraussetzungen

Für diesen Leitfaden benötigen Sie Folgendes:

• Einen oder mehrere Linux-Server mit NVIDIA-GPUs (Ampere oder neuer wird empfohlen, aber ältere Architekturen funktionieren auch).
• Installierten und funktionierenden NVIDIA-Treiber. Überprüfen Sie das mit `nvidia-smi`. Fehlt der Befehl, installieren Sie zuerst den Treiber aus dem Repository Ihrer Distribution.
• Python 3.8 oder neuer, plus `pip`.
• Grundlegende Vertrautheit mit der Kommandozeile und systemd.
• Optional: einen Kubernetes-Cluster, wenn Sie den fortgeschrittenen Orchestrierungsbeispielen folgen möchten. Für den Kernartikel reicht ein einzelner Server.

Wir bauen unseren Management-Stack aus drei Komponenten:

1. `nvidia-smi` – das Standard-NVIDIA-Kommandozeilentool zur Abfrage des GPU-Zustands. 2. `pynvml` – eine offizielle NVIDIA-Python-Bindung, mit der wir Überwachungsskripte schreiben können. 3. `cron` und `systemd` – die eingebauten Scheduler des Betriebssystems, die überraschend leistungsfähig werden, wenn man sie mit dem erfassten GPU-Zustand kombiniert.

Optional installieren wir Ollama, um lokale LLM-Inferenz als eine Möglichkeit bereitzustellen, Lücken im Leerlauf mit nützlicher Arbeit zu füllen. OLLAMAS Blog hat dokumentiert, wie einfach es ist, eine ungenutzte GPU in einen selbst gehosteten Modellserver zu verwandeln, und sowohl der Mistral AI News als auch der Meta AI Blog kündigen regelmäßig neue Open-Weights-Modelle an, die Sie lokal bereitstellen können. Als periodischer „Hintergrund-Workload" verwendet, macht dies ungenutzte GPU-Zeit zu einem Feature und nicht zu einer Kostenstelle.

Schritt-für-Schritt-Installation

Schritt 1: NVIDIA-Treiber-Stack überprüfen und installieren

Stellen Sie zunächst sicher, dass Ihre GPU für das System sichtbar ist. Führen Sie aus:

nvidia-smi

Wenn der Befehl nicht gefunden wird, installieren Sie ihn. Unter Ubuntu 22.04 oder neuer:

sudo apt update
sudo apt install -y nvidia-driver-535
sudo reboot

Nach dem Neustart erneut überprüfen:

nvidia-smi --query-gpu=index,name,utilization.gpu,memory.used --format=csv

Sie sollten eine Tabelle sehen, die jeden GPU-Index, Namen, aktuelle Auslastung und Speichernutzung auflistet. Das ist Ihre Basislinie.

Schritt 2: Python-Bindungen installieren

Installieren Sie als Nächstes `pynvml`. Diese offizielle NVIDIA-Bibliothek gibt uns programmatischen Zugriff auf die gesamte Telemetrie, die in `nvidia-smi` sichtbar ist. Wir installieren auch `psutil` für Systemmetriken:

pip install nvidia-ml-py psutil

Hinweis: Das Paket heißt `nvidia-ml-py`, aber der Import ist `pynvml`. Das ist eine häufige Quelle von Verwirrung.

Schritt 3: Ein Überwachungsskript schreiben

Erstellen Sie eine Datei mit dem Namen `gpu_monitor.py`:

#!/usr/bin/env python3
import pynvml
import time
import csv
import os

pynvml.nvmlInit()
device_count = pynvml.nvmlDeviceGetCount()
log_file = "gpu_utilization.csv"

def log_gpu_state():
    with open(log_file, "a", newline="") as f:
        writer = csv.writer(f)
        writer.writerow([time.time()] + [get_device_state(i) for i in range(device_count)])

def get_device_state(index):
    handle = pynvml.nvmlDeviceGetHandleByIndex(index)
    util = pynvml.nvmlDeviceGetUtilizationRates(handle)
    memory = pynvml.nvmlDeviceGetMemoryInfo(handle)
    power = pynvml.nvmlDeviceGetPowerUsage(handle)
    return f"{util.gpu}%|{util.memory}%|{memory.used / 1024**2:.0f}MiB|{power / 1000:.1f}W"

if __name__ == "__main__":
    while True:
        log_gpu_state()
        time.sleep(30)  # Sample every 30 seconds

Testen Sie das Skript:

python3 gpu_monitor.py &

Lassen Sie es eine Minute lang laufen und prüfen Sie dann die Ausgabe:

cat gpu_utilization.csv

Sie werden Zeilen sehen wie `1724733600.0, 3%|5%|512MiB|38.2W, 98%|100%|79123MiB|392.1W`. Wenn Ihre GPUs eher wie der erste Eintrag aussehen als wie der zweite, haben Sie ein Stillstandsproblem.

Schritt 4: Einen systemd-Dienst für dauerhafte Telemetrie einrichten

Ein Monitor, der in einer Vordergrund-Shell läuft, ist keine Überwachungslösung. Erstellen Sie einen Dienst, damit Ihre Telemetrie Neustarts übersteht:

sudo nano /etc/systemd/system/gpu-monitor.service

Fügen Sie Folgendes hinzu:

[Unit]
Description=GPU utilization logger
After=multi-user.target

[Service]
WorkingDirectory=/opt/gpu-monitor
ExecStart=/usr/bin/python3 /opt/gpu-monitor/gpu_monitor.py
Restart=always

[Install]
WantedBy=multi-user.target

Verschieben Sie nun Ihr Skript, aktivieren Sie den Dienst und starten Sie ihn:

sudo mkdir -p /opt/gpu-monitor
sudo mv gpu_monitor.py /opt/gpu-monitor/
sudo systemctl daemon-reload
sudo systemctl enable --now gpu-monitor

Herzlichen Glückwunsch. Sie haben jetzt eine kontinuierliche, historische Aufzeichnung der Auslastung, des Speichers und der Leistungsaufnahme jeder GPU – das Äquivalent zu einem Flugdatenschreiber für Ihre Beschleunigerflotte.

Schritt 5: Ollama für Hintergrund-Inferenz installieren

Ollama ist der schnellste Weg, Leerlaufzyklen in nützliche Arbeit zu verwandeln. Es ist ein einzelnes Binärprogramm, das den Modell-Server für lokale LLMs kapselt, und sein Blog hat ein wachsendes Ökosystem von Modellen dokumentiert, die Sie abrufen und ausführen können. So installieren Sie es:

curl -fsSL https://ollama.com/install.sh | sh

Das Installationsskript richtet einen systemd-Dienst für Sie ein. Überprüfen Sie ihn:

sudo systemctl status ollama

Ziehen Sie dann ein Modell. Da sowohl Mistral AI als auch Meta Open-Weights-Modelle veröffentlichen, die Ollama unterstützt, können Sie je nach Ihrem Speicherbudget wählen:

ollama pull llama3

Oder für ein kleineres Modell, das auf einer einzelnen GPU mit minimalem Speicher läuft:

ollama pull mistral

Sobald ein Modell gezogen ist, bleibt der Serverprozess im GPU-Speicher resident und wartet auf eine Anfrage. Wenn Ihre Trainingsjobs laufen, können Sie Ollama stoppen oder mit `CUDA_VISIBLE_DEVICES` auf eine andere GPU verschieben. Das verwandelt Ihre „ungenutzten" GPUs in einen privaten Inferenz-Endpunkt – wertvoll für Entwickler, QA-Teams und Dokumentverarbeitungspipelines im gesamten Unternehmen.

Anwendungsbeispiele

Beispiel 1: Zombie-GPU-Prozesse erkennen und beenden

Das zerstörerischste Muster in jeder GPU-Flotte ist ein Prozess, der Speicher belegt, aber keine Berechnungen durchführt – ein gelandetes Flugzeug mit ausgeschalteten Triebwerken, aber angezogener Parkbremse. Verwenden Sie diesen Befehl, um Prozesse aufzulisten, die GPU-Speicher belegen:

nvidia-smi --query-compute-apps=pid,used_memory,process_name --format=csv

Wenn Sie veraltete `python3`-Prozesse sehen, identifizieren Sie deren Elternprozess und beenden Sie sie:

ps aux | grep <pid>
sudo kill <pid>

Um dies zu einer wiederkehrenden Routine zu machen, fügen Sie es zu `cron` hinzu:

crontab -e

Fügen Sie die folgende Zeile hinzu, um das Tötungsskript jede Stunde auszuführen:

0 * * * * /opt/gpu-monitor/cleanup_gpus.sh

Der Inhalt des Skripts kann eine einfache Schleife sein, die Prozesse findet, die mehr als null Speicher verwenden, aber seit mehr als 10 Minuten eine GPU-Auslastung von 0 % haben. Das ist das Nächstbeste zu einer automatisierten Bodenbesatzungs-Inspektion, die Ihre GPUs je hatten.

Beispiel 2: Dynamische Planung mit `CUDA_VISIBLE_DEVICES`

Die wirksamste einzelne Disziplin für das GPU-Management ist die explizite Gerätezuweisung. Lassen Sie PyTorch oder TensorFlow nicht zufällig eine GPU auswählen, sondern setzen Sie immer die Umgebungsvariable:

CUDA_VISIBLE_DEVICES=2 python3 train.py

Wenn Sie einen Multi-GPU-Trainingsjob ausführen, begrenzen Sie den sichtbaren Satz:

CUDA_VISIBLE_DEVICES=0,1,2,3 torchrun --nproc_per_node=4 train.py

Kombinieren Sie dies mit einem schnellen Python-Check, um vor dem Start eines Jobs die am wenigsten ausgelastete GPU zu finden:

import pynvml
pynvml.nvmlInit()
best_idx = -1
best_util = 101
for i in range(pynvml.nvmlDeviceGetCount()):
    handle = pynvml.nvmlDeviceGetHandleByIndex(i)
    util = pynvml.nvmlDeviceGetUtilizationRates(handle).gpu
    if util < best_util:
        best_util = util
        best_idx = i
print(best_idx)

Speichern Sie dies als `pick_gpu.py` und umschließen Sie Ihren Trainingsbefehl:

export BEST_GPU=$(python3 pick_gpu.py)
CUDA_VISIBLE_DEVICES=$BEST_GPU python3 train.py

Dieses einfache Muster beseitigt die schlimmste Form ungenutzter GPUs: die reservierte, aber unbenutzte Karte.

Beispiel 3: Leerlaufzeitfenster mit Ollama-Stapelverarbeitung füllen

Stellen Sie sich vor, Sie haben eine GPU, die jede Nacht von Mitternacht bis 6 Uhr morgens ungenutzt ist. Lassen Sie dieses Kapitalgut nicht auf dem „Rollfeld" stehen, sondern planen Sie einen Stapeljob, der mit Ollama eine Warteschlange vorhandener Anfragen verarbeitet. Hier ist ein kleiner Python-Batch-Client:

import requests
import json

with open("texts.json") as f:
    texts = json.load(f)

for text in texts:
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={"model": "mistral", "prompt": f"Summarize: {text}", "stream": False}
    )
    result = response.json()
    print(result.get("response", ""))

Führen Sie dies mit einem Cron-Job aus:

0 0 * * * /usr/bin/python3 /opt/batch_inference.py >> /var/log/batch_inference.log 2>&1

Ihre GPU verrichtet nun während eines sonst toten Zeitfensters nützliche Arbeit. Genau das ist der Unterschied zwischen einem geparkten Flugzeug und einem arbeitenden.

Beispiel 4: Alarmierung bei GPU-Unterversorgung

Schreiben Sie ein Skript, das die letzten 10 Zeilen Ihres CSV-Protokolls prüft und eine Metrik ausgibt, wenn die Auslastung seit über einer Stunde unter 10 % liegt:

import sys
import csv

rows = list(csv.reader(open("/opt/gpu-monitor/gpu_utilization.csv")))
if len(rows) < 20:
    print("Not enough samples yet.")
    sys.exit(0)

# Parse GPU 0 utilization from the last 20 samples
recent_u = [float(r[1].split("|")[0].rstrip("%")) for r in rows[-20:]]
avg_util = sum(recent_u) / len(recent_u)
if avg_util < 10:
    print(f"ALERT: GPU 0 average utilization {avg_util:.1f}% over the last 10 minutes.")
else:
    print(f"OK: GPU 0 average utilization {avg_util:.1f}%.")

Wenn Sie eine ausgereifte Alarmierungspipeline möchten, exportieren Sie diese Zahlen nach Prometheus und visualisieren Sie sie in Grafana. Der CSV-Ansatz ist jedoch elegant, weil er keine zusätzliche Infrastruktur benötigt – kein Kubernetes, keine Exporter, keine Zeitreihendatenbank.

Über den einzelnen Server hinaus: Flottenmanagement

Die obigen Befehle funktionieren gut für einen einzelnen Rechner. In einem Kubernetes-Cluster wird das Problem auf Plattformebene gelöst. Das offizielle NVIDIA-Device-Plugin für Kubernetes macht GPUs als planbare Ressourcen verfügbar, und Operatoren wie der NVIDIA GPU Operator erweitern dies auf MIG (Multi-Instance GPU) Slicing. Der Blog von Hugging Face hat diese Muster ausführlich behandelt und sie als zentral für kosteneffizientes Modell-Serving und Training im großen Maßstab positioniert.

Wenn Ihre Organisation noch nicht auf Kubernetes ist, ist die Disziplin dennoch anwendbar: Standardisieren Sie auf `CUDA_VISIBLE_DEVICES`, erzwingen Sie ein Reservierungssystem mit Wanduhrzeit und protokollieren Sie die Auslastung überall. Die Werkzeuge sind zweitrangig gegenüber der Gewohnheit des Messens.

Fazit

Eine ungenutzte GPU ist ein geparktes Flugzeug: ein gewaltiges Kapitalgut, das keine umsatzbringende Arbeit verrichtet, während es Strom verbrennt, Kühlkapazität belegt und die Bilanz belastet. Die Lösung ist nicht, mehr GPUs zu kaufen. Die Lösung ist, eine Überwachungsschleife zu installieren, eine explizite Geräteplanung zu erzwingen und wirklich ungenutzte Zeitfenster mit Hintergrund-Inferenzjobs zu füllen.

Die Befehle in diesem Artikel sind bewusst einfach gehalten. Ein Python-Skript, ein Cron-Job, ein systemd-Dienst und ein lokaler Modellserver. Zusammen geben sie Ihnen, was den meisten KI-Organisationen fehlt: Sichtbarkeit. Mit Sichtbarkeit kommt Auslastung; mit Auslastung kommt eine Rendite auf die Millionen Dollar, die Sie bereits ausgegeben haben. Ihre Flotte steht auf dem Rollfeld und wartet auf einen Piloten. Sie haben jetzt die Cockpit-Instrumente, um sie zu fliegen.