Aller au contenu
Copyright © 2022-2026 basebox GmbH, all rights reserved.
Licensed to be used in conjunction with basebox, only.

// installation

Server vorbereiten

Schritt 2 von 10 · Weg A (Bare Metal)

Gilt für

Produkt: Server · Zielgruppe: Platform Operator

Letzte Aktualisierung: 10. Februar 2026
Dokumentversion: 2.1.4

Was diese Seite abdeckt

Diese Seite ist Schritt 2 der Bare-Metal-Installation: Betriebssystem und Grundsystem – Ubuntu installieren, Netzzugang prüfen, Systemkonfiguration (Shared Memory, Firewall), Sicherheit und Wartung des Hosts. Die Abschnitte zu NVIDIA-Treiber, CUDA, Container Toolkit, Docker, Kubernetes und GPU Operator bleiben hier als Gesamtreferenz stehen. Maßgeblich für diese Themen sind aber die Schritte 3 · NVIDIA / GPU und 4 · Kubernetes. Wenn Sie dem Pfad folgen, führen Sie auf dieser Seite die Prüfungen vor der Installation, „Schritt 1: Ubuntu Server installieren“ und „Schritt 8: Systemkonfiguration“ aus und fahren dann mit Schritt 3 des Pfads fort.

Anwendungsserver ohne GPU

Dieser Leitfaden geht davon aus, dass der Server basebox-GPU-Workloads ausführt. Nutzt basebox einen Inferenz-Endpunkt auf einem separaten GPU-Server, kann der Anwendungsserver rein CPU-basiert sein. Installieren Sie dort die normale Container-Runtime, Kubernetes, Ingress, Speicher und CloudNativePG, lassen Sie aber NVIDIA-Treiber, CUDA, NVIDIA Container Toolkit und GPU Operator auf diesem CPU-Server weg. Siehe Deployment-Topologien.

Schnellstart

Kurzfassung für erfahrene Systemadministratoren:

  1. Ubuntu 24.04 LTS Server installieren (Download)
  2. NVIDIA-Treiber installieren: sudo ubuntu-drivers autoinstall && sudo reboot
  3. CUDA Toolkit 13.0 installieren (Details in Schritt 3)
  4. Docker + NVIDIA Container Toolkit installieren (siehe Schritte 4–5)
  5. Kubernetes 1.33+ mit GPU Operator installieren (siehe Schritte 6–7)

basebox-Support kontaktieren: support@basebox.ai für Unterstützung beim Deployment

Hinweis: Dieser Leitfaden beschreibt den empfohlenen Weg für Neuinstallationen. Haben Sie bestehende Infrastruktur oder andere Anforderungen, kontaktieren Sie support@basebox.ai

Das Wichtigste in Kürze

Empfohlenes Betriebssystem: Ubuntu 24.04 LTS

Zentrale Anforderungen:

  • Ubuntu 24.04 LTS Server (die empfohlene Version für Neuinstallationen)
  • NVIDIA-GPU mit CUDA-Unterstützung (Compute Capability 7.0+)
  • NVIDIA-Treiber kompatibel mit CUDA 13.0+
  • CUDA Toolkit 13.0 (immer die neueste Version installieren)
  • Docker Engine 24.0+ oder containerd 2.0+
  • Kubernetes 1.33+ mit GPU Operator (für Produktiv-Deployments erforderlich)
  • Mindestens 8 CPU-Kerne, 16GB RAM, 500GB Speicher (je nach Deployment-Größe)
  • Netzzugang zur Container-Image-Registry während der Installationsphase (abgeschottete Deployments über Offline-Image-Transfer unterstützt – Details bei support@basebox.ai)

Hinweis: Ubuntu 22.04 LTS wird für bestehende Systeme unterstützt. Für Neuinstallationen immer Ubuntu 24.04 LTS verwenden.

Warum Ubuntu 24.04 LTS:

  • NVIDIA-CUDA-Dokumentation und -Unterstützung
  • Längster Support-Zyklus (bis April 2029)
  • Umfangreiche Docker- und Kubernetes-Community-Ressourcen
  • Industriestandard für GPU-beschleunigte Workloads

Nicht unterstützt: Microsoft Windows (vLLM erfordert Linux; Windows Server bietet keine native GPU-Container-Unterstützung)

Geprüfte Softwareversionen

Dieser Leitfaden wurde zuletzt mit folgenden Softwareversionen getestet:

Komponente Getestete Version Aktuellen Stand prüfen Zuletzt verifiziert
Ubuntu 24.04 LTS Download Feb 2026
NVIDIA-Treiber 580.126.09 Prüfen Feb 2026
CUDA Toolkit 13.0.0 Prüfen Feb 2026
Docker 29.2.1 Prüfen Feb 2026
containerd 1.7.x Mit Docker gebündelt Feb 2026
Kubernetes 1.33.7 Prüfen Feb 2026
Helm 3.20.0 Prüfen Feb 2026
Calico CNI 3.31.3 Prüfen Feb 2026
GPU Operator Neueste Automatisch aktualisiert über Helm Feb 2026

⚠️ Wichtig ⚠️: Diese Versionen ändern sich häufig. Prüfen Sie vor der Installation immer die verlinkte offizielle Dokumentation.

Einführung

Dieser Leitfaden bietet Schritt-für-Schritt-Anweisungen zur Vorbereitung einer neuen Servermaschine für ein basebox-Server-Deployment. Die Empfehlungen beruhen auf unserer Erfahrung mit GPU-beschleunigten KI-Inferenz-Workloads mit vLLM 0.14.0, Docker und Kubernetes in Produktivumgebungen.

basebox ist ein Rust-basiertes Backend mit Vue-Frontend, das für die LLM-Inferenz GPU-Beschleunigung benötigt. Wir empfehlen für alle Produktiv-Deployments Kubernetes (mit Helm). Dieser Leitfaden konzentriert sich auf die Vorbereitung des Betriebssystems und des grundlegenden Software-Stacks.

Dokumentationsansatz:

Dieser Leitfaden enthält auf basebox-Deployments zugeschnittene Schritt-für-Schritt-Anweisungen. Details und aktuelle Updates stehen in der offiziellen Dokumentation von NVIDIA, Docker, Kubernetes und Ubuntu; dieser Leitfaden bündelt die für basebox wesentlichen Schritte und Konfigurationen. Jeder Abschnitt enthält Links zur offiziellen Dokumentation, die für verbindliche Informationen, Fehlersuche und fortgeschrittene Konfigurationen zuerst konsultiert werden sollte.

🚨 WICHTIG: KI-Infrastruktur entwickelt sich schnell

Die Ökosysteme von CUDA, Kubernetes, Docker und GPU-Software veröffentlichen häufig Updates – teils wöchentlich. Dieser Leitfaden beschreibt einen im Februar 2026 erprobten Installationsweg, aber Softwareversionen können sich seit der Veröffentlichung geändert haben.

Prüfen Sie IMMER zuerst die offizielle Dokumentation: - Jeder Schritt enthält oben Links zur offiziellen Dokumentation - Aktuelle stabile Versionen vor dem Ausführen von Befehlen prüfen - Kompatibilitätsmatrizen prüfen (CUDA ↔ Treiber ↔ GPU-Modell) - Wenn möglich zuerst in einer Nicht-Produktivumgebung testen

Unser Leitfaden bündelt die wesentlichen Schritte für basebox-Anforderungen, aber die offizielle Dokumentation ist maßgeblich für aktuelle Versionen, Fehlersuche und fortgeschrittene Konfigurationen.

Im Zweifel: support@basebox.ai für aktuelle Versionsempfehlungen kontaktieren.

Wichtige Hinweise:

  • Anforderungen können je nach Deployment-Konfiguration variieren
  • Abgeschottete Deployments werden unterstützt – Offline-Installationsverfahren bei support@basebox.ai
  • Hardware-Spezifikationen hängen von GPU-Modellen und Workload-Anforderungen ab
  • Weicht Ihre Umgebung von diesen Empfehlungen ab, kontaktieren Sie support@basebox.ai

Checkliste vor der Installation

Prüfen Sie vor Beginn der Installation:

Hardware-Inventar:

  • NVIDIA-GPU(s) installiert und vom BIOS erkannt (nach der OS-Installation lspci | grep -i nvidia ausführen)
  • GPU Compute Capability 7.0+ (V100, T4, RTX20xx, A100, L4, H100 etc.)
  • Mindestens 8 CPU-Kerne (16+ für Produktion empfohlen)
  • Mindestens 16GB RAM (32GB+ empfohlen, 64GB+ für große Modelle)
  • Mindestens 500GB Speicher (1TB+ für Modellspeicher empfohlen)
  • Ausreichende Stromversorgung und Kühlung für die GPUs

Netzwerkanforderungen:

  • Internetverbindung während der Installation (oder Offline-Installationspakete vorbereitet)
  • Erforderliche Ports erreichbar (22/TCP für SSH, 6443/TCP für K8s-API falls zutreffend)
  • Zugangsdaten für die Serververwaltung

Zugang und Sicherheit:

  • Physischer oder Fernzugang zum Server (IPMI, iLO o. Ä.)
  • BeyondTrust PRA oder vergleichbares Privileged Access Management konfiguriert (falls zutreffend)
  • Backup-Plan für bestehende Daten (falls keine Neuinstallation)

Installationsmedien:

  • Ubuntu 24.04 LTS Server ISO heruntergeladen
  • USB-Stick oder DVD für die Installation (falls keine Ferninstallation)

Prüfbefehle (nach der OS-Installation ausführen): 

# Check CPU cores
lscpu | grep "^CPU(s):"

# Check RAM
free -h

# Check storage
df -h

# Check GPU detection
lspci | grep -i nvidia

Probleme oder abweichende Anforderungen? Kontaktieren Sie support@basebox.ai, bevor Sie fortfahren.

Erforderlicher Netzzugang

Für eine erfolgreiche Installation muss der Server Netzzugang zu den folgenden Domains und URLs haben. Stellen Sie sicher, dass Ihre Firewall ausgehende HTTPS-Verbindungen (443/TCP) zu diesen Endpunkten erlaubt:

Paket-Repositories (Installationsphase)

Ubuntu-Paket-Repositories:

  • archive.ubuntu.com – Ubuntu-Paket-Repository
  • security.ubuntu.com – Ubuntu-Sicherheitsupdates

Docker:

  • download.docker.com – Docker-Engine-Pakete und GPG-Schlüssel
  • *.docker.com – Docker-Registry und -Dokumentation

Kubernetes:

  • pkgs.k8s.io – Kubernetes-Pakete (kubelet, kubeadm, kubectl)
  • raw.githubusercontent.com – Kubernetes-Manifeste und -Skripte

NVIDIA:

  • developer.download.nvidia.com – CUDA-Toolkit-Pakete
  • developer.nvidia.com – CUDA-Downloads und -Dokumentation
  • nvidia.github.io – Repositories für NVIDIA Container Toolkit und GPU Operator
  • helm.ngc.nvidia.com – NVIDIA-Helm-Chart-Repository

Helm:

  • raw.githubusercontent.com/helm/helm – Helm-Installationsskripte
  • get.helm.sh – Helm-Binary-Downloads

Container-Registries (Betriebsphase):

  • registry-1.docker.io – Docker Hub (für Basis-Images)
  • gcr.io – Google Container Registry (für einige Kubernetes-Images)
  • k8s.gcr.io / registry.k8s.io – Kubernetes-Container-Images
  • quay.io – Container-Registry (für einige Kubernetes-Komponenten)

Netzwerk-Plugins:

  • raw.githubusercontent.com/projectcalico – Calico-CNI-Manifeste

Netzwerkverbindung testen

Prüfen Sie vor der Installation den Zugang zu den kritischen Endpunkten:

# Test DNS resolution
nslookup pkgs.k8s.io
nslookup download.docker.com
nslookup developer.download.nvidia.com

# Test HTTPS connectivity
curl -I https://pkgs.k8s.io
curl -I https://download.docker.com
curl -I https://developer.download.nvidia.com

# Test specific endpoints
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.33/deb/Release.key
curl -fsSL https://download.docker.com/linux/ubuntu/gpg

Hinweis: Für abgeschottete Umgebungen kontaktieren Sie support@basebox.ai für Offline-Installationsverfahren und Anforderungen an den Image-Transfer.

Empfohlenes Betriebssystem: Ubuntu LTS

Ubuntu 24.04 LTS

Ubuntu 24.04 LTS (Noble Numbat)

  • Release: April 2024
  • Support bis: April 2029
  • Download: Ubuntu 24.04 LTS Server
  • Architektur: x86_64
  • Neuestes LTS-Release mit verlängertem Support
  • NVIDIA-CUDA-Unterstützung und -Dokumentation

Hinweis: Ubuntu 22.04 LTS wird für bestehende Systeme unterstützt, auf denen basebox bereits läuft. Für alle Neuinstallationen Ubuntu 24.04 LTS verwenden.

Schritt-für-Schritt-Installationsleitfaden

Hinweis: Jeder Schritt unten beginnt mit Links zur offiziellen Dokumentation. Wir empfehlen, zuerst die offizielle Dokumentation zu lesen und dann die Schritte unten für die basebox-spezifische Installation zu nutzen. Der Leitfaden bündelt die für basebox wesentlichen Schritte.

Schritt 1: Ubuntu Server installieren

Offizielle Dokumentation:

Kurz:

  1. Ubuntu-Server-ISO herunterladen

  2. Installationsmedium erstellen

    • ISO mit Werkzeugen wie Rufus (Windows) oder dd (Linux) auf einen USB-Stick schreiben
    • Vom Installationsmedium booten

  3. Installationsoptionen

    • „Ubuntu Server" wählen (Minimalinstallation)
    • „Use an entire disk" für automatische Partitionierung wählen (oder bei Bedarf benutzerdefiniert)
    • Benutzerkonto und Hostname einrichten
    • OpenSSH-Server während der Installation aktivieren (für Fernzugang empfohlen)

  4. Nach der Installation

    # Update package lists
sudo apt update && sudo apt upgrade -y

# Reboot if kernel was updated
sudo reboot

Schritt 2: NVIDIA-GPU-Treiber installieren

Offizielle Dokumentation:

Voraussetzungen:

  • NVIDIA-GPU installiert und erkannt: lspci | grep -i nvidia
  • Internetverbindung für Treiber-Downloads

NVIDIA-Treiberinstallation (empfohlene Methode):

# Install latest NVIDIA drivers automatically
sudo ubuntu-drivers autoinstall

# Reboot to load drivers
sudo reboot

# Verify installation
nvidia-smi

Prüfung:

# Check driver version (should be 550+ for CUDA 13.0 support)
nvidia-smi

# Expected output shows:
# - Driver Version: 550.xx.xx or higher
# - CUDA Version: 13.0+
# - GPU(s) listed with memory information

Schritt 3: CUDA Toolkit installieren

CUDA Toolkit 13.0 installieren:

Installieren Sie immer CUDA 13.0 – die neueste Version. CUDA 12.9 wird als Rückfalloption unterstützt, falls 13.0 nicht verfügbar ist.

Offizielle Dokumentation:

# Add NVIDIA CUDA repository
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/cuda-keyring_1.1-1_all.deb
sudo dpkg -i cuda-keyring_1.1-1_all.deb
sudo apt-get update

# Install CUDA Toolkit 13.0
sudo apt-get install -y cuda-toolkit-13-0

# Set environment variables (add to ~/.bashrc)
echo 'export PATH=/usr/local/cuda-13.0/bin${PATH:+:${PATH}}' >> ~/.bashrc
echo 'export LD_LIBRARY_PATH=/usr/local/cuda-13.0/lib64${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}' >> ~/.bashrc
source ~/.bashrc

# Verify installation
nvcc --version

Rückfalloption (CUDA 12.9):

Nutzen Sie CUDA 12.9, falls CUDA 13.0 in Ihrem Repository nicht verfügbar ist:

sudo apt-get install -y cuda-toolkit-12-9
echo 'export PATH=/usr/local/cuda-12.9/bin${PATH:+:${PATH}}' >> ~/.bashrc
echo 'export LD_LIBRARY_PATH=/usr/local/cuda-12.9/lib64${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}' >> ~/.bashrc
source ~/.bashrc

Schritt 4: Docker Engine installieren

Anforderungen: Docker Engine 24.0+ (mit containerd 2.0+ für Kubernetes 1.35+)

Offizielle Dokumentation:

# Remove old versions
sudo apt-get remove docker docker-engine docker.io containerd runc

# Add Docker's official GPG key
sudo apt-get update
sudo apt-get install -y ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# Add Docker repository
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Install Docker Engine
sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Start and enable Docker
sudo systemctl start docker
sudo systemctl enable docker

# Add current user to docker group (optional, for non-root access)
sudo usermod -aG docker $USER
# Log out and back in for group changes to take effect

# Verify installation
docker --version
sudo docker run hello-world

Schritt 5: NVIDIA Container Toolkit installieren

Hinweis: Installieren Sie Kubernetes mit GPU Operator (Schritte 6–7), können Sie diesen Schritt überspringen – der GPU Operator installiert und konfiguriert das NVIDIA Container Toolkit automatisch.

Offizielle Dokumentation:

Erforderlich für Docker-Deployments: 

# Configure the production repository (generic DEB repository)
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | \
    sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg

curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
    sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

sudo apt-get update

# Install NVIDIA Container Toolkit
sudo apt-get install -y nvidia-container-toolkit

# Configure Docker to use NVIDIA runtime
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

# Verify GPU access in containers
sudo docker run --rm --gpus all nvidia/cuda:12.9.0-base-ubuntu22.04 nvidia-smi

Schritt 6: Helm installieren (für Kubernetes-Deployment erforderlich)

Offizielle Dokumentation:

Helm installieren (für Kubernetes-Deployment erforderlich):

# Download Helm
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

# Verify installation
helm version

Schritt 7: Kubernetes installieren (für Produktion erforderlich)

Kubernetes 1.33+ installieren:

Kubernetes ist für alle Produktiv-Deployments erforderlich. Installieren Sie Kubernetes 1.33 oder neuer.

Offizielle Dokumentation:

# Install required packages
sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl gpg

# Add Kubernetes repository (for 1.33)
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.33/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.33/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

# Install Kubernetes components
sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

# Disable swap (required for Kubernetes)
sudo swapoff -a
sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

# Set kernel parameters for Kubernetes (required before kubeadm init)
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF

sudo modprobe overlay
sudo modprobe br_netfilter

cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables  = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward                 = 1
EOF

sudo sysctl --system

# Configure containerd for Kubernetes (required before kubeadm init)
# The default containerd config may have CRI plugin disabled
sudo mkdir -p /etc/containerd
containerd config default | sudo tee /etc/containerd/config.toml > /dev/null
sudo systemctl restart containerd
sudo systemctl enable containerd

# Verify containerd is running
sudo systemctl status containerd

# Initialize Kubernetes cluster (on master node)
sudo kubeadm init --pod-network-cidr=10.244.0.0/16

# Set up kubeconfig for regular user
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

# Install network plugin (Calico example)

kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.31.3/manifests/calico.yaml

# Install NVIDIA GPU Operator (Production-ready with tolerations)
helm repo add nvidia https://helm.ngc.nvidia.com/nvidia
helm repo update

# Create values file with tolerations for control-plane nodes
cat <<EOF > gpu-operator-values.yaml
# Tolerations for Node Feature Discovery components
node-feature-discovery:
  master:
    tolerations:
      - key: node-role.kubernetes.io/control-plane
        operator: Exists
        effect: NoSchedule
  worker:
    tolerations:
      - key: node-role.kubernetes.io/control-plane
        operator: Exists
        effect: NoSchedule
  gc:
    tolerations:
      - key: node-role.kubernetes.io/control-plane
        operator: Exists
        effect: NoSchedule

# Tolerations for GPU Operator itself
operator:
  tolerations:
    - key: node-role.kubernetes.io/control-plane
      operator: Exists
      effect: NoSchedule
EOF

# Install with custom values
helm install --wait --timeout 15m --generate-name \
  -n gpu-operator --create-namespace \
  -f gpu-operator-values.yaml \
  nvidia/gpu-operator

# Verify installation
kubectl get pods -n gpu-operator
kubectl get daemonsets -n gpu-operator

Alternative: Installation ohne Tolerations (für Multi-Node-Cluster mit dedizierten Worker-Knoten):

Haben Sie einen Multi-Node-Cluster mit dedizierten Worker-Knoten (kein Control-Plane-Taint auf den Workern), können Sie die Installation ohne Tolerations nutzen:

helm install --wait --timeout 15m --generate-name \
  -n gpu-operator --create-namespace \
  nvidia/gpu-operator

Hinweis: Der Befehl oben zeigt die Standardinstallation für die meisten Setups. Haben Sie:

  • Vorinstallierte NVIDIA-Treiber (aus Schritt 2)
  • Abgeschottete/Offline-Umgebungen
  • MIG-fähige GPUs
  • Besondere Sicherheitsanforderungen

… kann eine andere GPU-Operator-Konfiguration nötig sein. Kontaktieren Sie support@basebox.ai für Hinweise zu Ihrem Setup.

Schritt 8: Systemkonfiguration

Systemeinstellungen konfigurieren:

Hinweis: Haben Sie Kubernetes in Schritt 7 installiert, sind Swap-Deaktivierung und Kernel-Parameter bereits konfiguriert. Diese Schritte unten können Sie überspringen.

# Increase shared memory size (required for model loading)
sudo mkdir -p /dev/shm

# Add entry to /etc/fstab (check if it already exists first)
if ! grep -q "/dev/shm" /etc/fstab; then
  echo 'tmpfs /dev/shm tmpfs defaults,size=64g 0 0' | sudo tee -a /etc/fstab
fi

# Reload systemd to pick up the new fstab entry
sudo systemctl daemon-reload

# Unmount and remount /dev/shm to apply new size
sudo umount /dev/shm 2>/dev/null || true
sudo mount /dev/shm

# Verify the new size (should show your configured size, e.g., 64G)
df -h /dev/shm

# Disable swap (required for Kubernetes - already done in Step 7 if following steps in order)
sudo swapoff -a
sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

# Set kernel parameters for Kubernetes (already done in Step 7 if following steps in order)
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF

sudo modprobe overlay
sudo modprobe br_netfilter

cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables  = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward                 = 1
EOF

sudo sysctl --system

# Configure firewall (if using UFW)
sudo ufw allow 22/tcp    # SSH
sudo ufw allow 6443/tcp  # Kubernetes API (if master)
sudo ufw allow 10250/tcp # Kubelet API
sudo ufw allow 80/tcp    # http
sudo ufw allow 443/tcp   # https
sudo ufw enable

Schritt 9: Prüf-Checkliste

Prüfen, dass alle Komponenten korrekt installiert sind:

# Check Ubuntu version
lsb_release -a

# Check NVIDIA driver
nvidia-smi

# Check CUDA toolkit
nvcc --version

# Check Docker
docker --version
sudo docker run --rm --gpus all nvidia/cuda:12.9.0-base-ubuntu22.04 nvidia-smi

# Check Kubernetes (if installed)
kubectl version --client
kubectl get nodes

# Check GPU Operator (if Kubernetes installed)
kubectl get pods -n gpu-operator

# Check system resources
free -h
df -h
lscpu

Alle Prüfungen bestanden? Weiter zum Deployment. Probleme? Siehe Abschnitt Troubleshooting oder support@basebox.ai kontaktieren

Getestete Konfiguration

Dieser Leitfaden wurde auf folgender Hardwarekonfiguration vollständig getestet und verifiziert:

Systemspezifikationen

Komponente Spezifikation Status
Betriebssystem Ubuntu 24.04.3 LTS (Noble) ✅ Verifiziert
CPU Intel Core i7-11800H @ 2.30GHz (8 Kerne, 16 Threads) ✅ Verifiziert
Arbeitsspeicher 15 GB RAM ✅ Verifiziert
Speicher 468 GB NVMe SSD (262 GB verfügbar) ✅ Verifiziert
GPU NVIDIA GeForce RTX 3050 Laptop GPU (4 GB VRAM) ✅ Verifiziert
Shared Memory 64 GB /dev/shm ✅ Verifiziert

Verifizierter Software-Stack

Komponente Version Prüfbefehl Status
NVIDIA-Treiber 580.126.09 nvidia-smi ✅ Verifiziert
CUDA Toolkit 13.0.88 nvcc --version ✅ Verifiziert
Docker 29.2.1 docker --version ✅ Verifiziert
Kubernetes 1.33.7 kubectl version --client ✅ Verifiziert
GPU Operator Neueste (über Helm) kubectl get pods -n gpu-operator ✅ Verifiziert

Ergebnisse der Installationsprüfung

Alle Komponenten erfolgreich installiert und verifiziert:

✅ Ubuntu 24.04.3 LTS - Confirmed via lsb_release -a
✅ NVIDIA Driver 580.126.09 - GPU detected and operational
✅ CUDA 13.0.88 - Compiler tools verified
✅ Docker 29.2.1 - Container runtime functional
✅ Kubernetes 1.33.7 - Single-node cluster (control-plane) running
✅ GPU Operator - All pods running:
   - node-feature-discovery-gc: Running
   - node-feature-discovery-master: Running
   - node-feature-discovery-worker: Running
   - gpu-operator: Running
✅ System Resources - Adequate for basebox deployment
✅ Shared Memory - 64 GB configured and mounted

Testdatum

Getestet: 9. Februar 2026

Testumgebung: Einzelknoten-Kubernetes-Cluster mit GPU Operator in produktionsreifer Konfiguration (mit Tolerations für den Control-Plane-Taint).

Alternative Betriebssysteme

Ubuntu 24.04 LTS ist das empfohlene Betriebssystem für basebox. Die folgende Tabelle fasst unsere Bewertung alternativer Betriebssysteme für basebox-Deployments zusammen:

Betriebssystem Beschreibung Vorteile Vergleich mit Ubuntu Empfehlung
Ubuntu 24.04 LTS Neuestes LTS-Release (April 2024) NVIDIA-CUDA-Dokumentation und -Unterstützung
Längster Support-Zyklus (bis April 2029)
Umfangreiche Docker-/Kubernetes-Community
Industriestandard für GPU-beschleunigte Workloads		 – (Referenz) ✅ Empfohlen – Für alle Neuinstallationen
Ubuntu 22.04 LTS Vorheriges LTS-Release (April 2022) Stabiles, gut getestetes Release
Gute NVIDIA-CUDA-Unterstützung
Support bis April 2027		 Älteres Release mit kürzerem Support-Zyklus
Weniger aktuelle CUDA-Toolkit-Pakete
Weniger Community-Ressourcen für neueste Funktionen		 ⚠️ Unterstützt – Nur für bestehende Systeme, auf denen basebox bereits läuft
Debian Stable Ubuntus Ursprungsdistribution Konservativere Paketversionen
Kleinerer Standard-Fußabdruck
Starker Sicherheitsfokus
Keine kommerziellen Bindungen		 Weniger NVIDIA-spezifische Dokumentation
Ältere CUDA-Toolkit-Pakete
Kleinere GPU-Workload-Community
Weniger Docker-/Kubernetes-Tutorials		 ⚠️ Unterstützt – Erfordert zusätzliche Konfiguration. Nicht offiziell getestet. Bei Bedarf Support kontaktieren
Red Hat Enterprise Linux (RHEL) Enterprise-Linux-Distribution Kommerzieller Support von Red Hat
Sicherheitshärtung und Compliance-Zertifizierungen
10 Jahre Support
Red-Hat-OpenShift-Integration
Partner-validierte GPU-Konfigurationen		 Lizenzkosten
Weniger zugängliche Dokumentation
Komplexere Installation
Weniger NVIDIA-Treiberpakete		 ⚠️ Funktioniert möglicherweise – In Betracht ziehen bei Bedarf an kommerziellen Supportverträgen oder bestehender RHEL-Infrastruktur
SUSE Linux Enterprise Server (SLES) Enterprise-Linux-Distribution Enterprise-Support verfügbar
Starke Sicherheitsfunktionen
Langzeit-Support		 Weniger NVIDIA-Ökosystem-Unterstützung
Kleinere Community
Höhere Kosten
Komplexeres Setup		 ⚠️ Funktioniert möglicherweise – Nur bei spezifischen SLES-Anforderungen oder bestehender SLES-Infrastruktur
Rocky Linux / AlmaLinux RHEL-kompatible Alternativen Community-gestützte RHEL-Alternativen
Keine Lizenzkosten
RHEL-Kompatibilität		 Weniger NVIDIA-spezifische Dokumentation
Begrenzte GPU-Workload-Community
Nicht umfassend mit basebox getestet		 ⚠️ Funktioniert möglicherweise – Nicht offiziell getestet. Gründlicher Test in Nicht-Produktivumgebung erforderlich
Microsoft Windows Server Windows-basiertes Server-OS Enterprise-Windows-Integration
Vertraute Windows-Administration		 vLLM erfordert Linux (unter Windows nicht unterstützt)
Begrenztes GPU-Container-Passthrough
Docker nutzt Hyper-V-Virtualisierung mit Overhead
Eingeschränkte Kubernetes-GPU-Unterstützung		 ❌ Nicht unterstützt – vLLM erfordert Linux. Stattdessen Ubuntu 24.04 LTS verwenden

Hinweise:

  • Ubuntu 24.04 LTS ist die offiziell unterstützte und empfohlene Distribution für Neuinstallationen
  • Alternative Linux-Distributionen funktionieren möglicherweise, erfordern aber zusätzliche Konfiguration, Tests und Fehlersuche

  • Müssen Sie eine alternative Distribution verwenden, gehen Sie so vor:

    1. NVIDIA-CUDA-Toolkit-Unterstützung für Ihre Distributionsversion prüfen
    2. Sicherstellen, dass Docker- und Kubernetes-Pakete verfügbar sind
    3. Zuerst gründlich in einer Nicht-Produktivumgebung testen
    4. support@basebox.ai für Unterstützung bei Nicht-Standard-Konfigurationen kontaktieren

  • Microsoft Windows Server wird wegen der Linux-Anforderung von vLLM nicht unterstützt

Troubleshooting-Entscheidungsbaum

Problem: GPU nicht erkannt

START: Run `nvidia-smi`
│
├─ ERROR: "command not found"
│  └─ SOLUTION: NVIDIA drivers not installed
│     └─ ACTION: Go to Step 2 and install drivers
│
├─ ERROR: "NVIDIA-SMI has failed because it couldn't communicate with the NVIDIA driver"
│  └─ SOLUTION: Driver installation incomplete or incorrect
│     └─ ACTION:
│        1. Run: sudo apt-get purge nvidia-*
│        2. Reinstall: sudo ubuntu-drivers autoinstall
│        3. Reboot: sudo reboot
│
├─ ERROR: "No devices were found"
│  └─ SOLUTION: GPU not recognized by system
│     └─ ACTION:
│        1. Check physical connection
│        2. Verify in BIOS: GPU should be visible
│        3. Check: lspci | grep -i nvidia
│        4. If not visible, hardware issue - check power/seating
│
└─ SUCCESS: GPU information displayed
   └─ NEXT: Verify CUDA version is 13.0 (or 12.9 as fallback)

Problem: CUDA-Versionskonflikt

START: Run `nvcc --version`
│
├─ ERROR: "command not found"
│  └─ SOLUTION: CUDA Toolkit not installed
│     └─ ACTION: Go to Step 3 and install CUDA Toolkit
│
├─ VERSION: CUDA 11.x or 12.0-12.8
│  └─ SOLUTION: CUDA version too old for vLLM 0.14.0
│     └─ ACTION:
│        1. Remove old CUDA: sudo apt-get purge cuda-*
│        2. Install CUDA 13.0 (see Step 3)
│        3. Update environment variables
│        4. Verify: nvcc --version
│
├─ VERSION: CUDA 13.0
│  └─ SUCCESS: Recommended version installed
│
├─ VERSION: CUDA 12.9
│  └─ ACCEPTABLE: Fallback version (use if 13.0 unavailable)
│
└─ ERROR: CUDA version doesn't match nvidia-smi
   └─ SOLUTION: Driver/toolkit mismatch
      └─ ACTION:
         1. Check driver supports CUDA version: nvidia-smi
         2. Install compatible driver (550+): see Step 2
         3. Reboot

Problem: Docker kann nicht auf die GPU zugreifen

START: Run `sudo docker run --rm --gpus all nvidia/cuda:12.9.0-base-ubuntu22.04 nvidia-smi`
│
├─ ERROR: "docker: Error response from daemon: could not select device driver"
│  └─ SOLUTION: NVIDIA Container Toolkit not installed
│     └─ ACTION: Go to Step 5 and install toolkit
│
├─ ERROR: "docker: unknown flag: --gpus"
│  └─ SOLUTION: Docker version too old
│     └─ ACTION:
│        1. Check version: docker --version
│        2. Upgrade Docker: sudo apt-get install --upgrade docker-ce
│        3. Restart: sudo systemctl restart docker
│
├─ ERROR: Permission denied or similar
│  └─ SOLUTION: NVIDIA runtime not configured
│     └─ ACTION:
│        1. Configure runtime: sudo nvidia-ctk runtime configure --runtime=docker
│        2. Restart Docker: sudo systemctl restart docker
│        3. Verify: cat /etc/docker/daemon.json
│
└─ SUCCESS: nvidia-smi output displayed in container
   └─ NEXT: Proceed with basebox deployment

Problem: Kubernetes-GPU nicht verfügbar

START: Run `kubectl get nodes -o json | jq '.items[].status.allocatable'`
│
├─ NO GPU RESOURCES SHOWN
│  └─ SOLUTION: GPU Operator not installed or not working
│     └─ ACTION:
│        1. Check pods: kubectl get pods -n gpu-operator
│        2. If missing: Install GPU Operator (see Step 6)
│        3. Check logs: kubectl logs -n gpu-operator <pod-name>
│        4. Verify node labels: kubectl get nodes --show-labels
│
├─ ERROR: Pods in CrashLoopBackOff
│  └─ SOLUTION: Configuration issue
│     └─ ACTION:
│        1. Check driver version: nvidia-smi
│        2. Verify containerd config: containerd config dump | grep nvidia
│        3. Check GPU Operator docs for compatibility
│        4. Contact support: support@basebox.ai
│
└─ SUCCESS: nvidia.com/gpu resources shown
   └─ NEXT: Deploy basebox workloads

Problem: kubeadm init scheitert mit „unknown service runtime.v1.RuntimeService"

START: Run `sudo kubeadm init --pod-network-cidr=10.244.0.0/16`
│
├─ ERROR: "unknown service runtime.v1.RuntimeService"
│  └─ SOLUTION: containerd CRI plugin is disabled in configuration
│     └─ ACTION:
│        1. Generate proper containerd config:
│           sudo mkdir -p /etc/containerd
│           containerd config default | sudo tee /etc/containerd/config.toml
│        2. Restart containerd:
│           sudo systemctl restart containerd
│           sudo systemctl enable containerd
│        3. Verify containerd is running:
│           sudo systemctl status containerd
│        4. Retry kubeadm init:
│           sudo kubeadm init --pod-network-cidr=10.244.0.0/16
│
├─ ERROR: "admin.conf: No such file or directory" (after failed init)
│  └─ SOLUTION: kubeadm init failed, so admin.conf was not created
│     └─ ACTION:
│        1. Fix containerd configuration (see above)
│        2. If cluster was partially initialized, reset first:
│           sudo kubeadm reset
│        3. Retry kubeadm init after fixing containerd
│
└─ SUCCESS: Cluster initialized successfully
   └─ NEXT: Continue with kubeconfig setup and network plugin installation

Problem: Netzwerk-/Verbindungsprobleme

START: Basic connectivity check
│
├─ Can't access package repositories
│  └─ ACTION:
│     1. Check internet: ping -c 4 8.8.8.8
│     2. Check DNS: nslookup ubuntu.com
│     3. Check firewall: sudo ufw status
│     4. For air-gapped: Contact support@basebox.ai for offline setup
│
├─ Can't pull Docker images
│  └─ ACTION:
│     1. Check Docker daemon: systemctl status docker
│     2. Check proxy settings if behind corporate proxy
│     3. Verify network access to registry
│     4. For air-gapped: Contact support@basebox.ai
│
└─ Kubernetes nodes not communicating
   └─ ACTION:
      1. Check firewall rules for K8s ports
      2. Verify pod network: kubectl get pods -A
      3. Check CNI plugin: kubectl get pods -n kube-system

Problem: Installationsprobleme mit dem GPU Operator

START: Install GPU Operator with Helm
│
├─ WARNING: "node-role.kubernetes.io/master is deprecated"
│  └─ SOLUTION: Harmless deprecation warning
│     └─ ACTION: Safely ignore - GPU Operator chart uses old label
│        └─ NOTE: Kubernetes deprecated master label in favor of control-plane
│
├─ ERROR: Any installation failure (timeout, resources exist, etc.)
│  └─ FIRST STEP: Clean up previous failed installation
│     └─ ACTION (RECOMMENDED - Most reliable cleanup):
│        1. Delete namespace (removes all resources):
│           kubectl delete namespace gpu-operator
│        2. Recreate namespace:
│           kubectl create namespace gpu-operator
│        3. Retry installation with proper values file
│     └─ ALTERNATIVE (if namespace deletion doesn't work):
│        1. List releases: helm list -n gpu-operator
│        2. Uninstall: helm uninstall <release-name> -n gpu-operator
│        3. Manually clean resources if needed:
│           kubectl delete all --all -n gpu-operator
│           kubectl delete sa --all -n gpu-operator
│
├─ ERROR: "context deadline exceeded"
│  └─ SOLUTION: Installation timed out waiting for pods
│     └─ CAUSES:
│        - GPU Operator images are large (several GB)
│        - Multiple images need to be pulled
│        - Network connectivity issues
│        - Nodes may not be ready
│     └─ ACTION:
│        1. Clean up first: kubectl delete namespace gpu-operator && kubectl create namespace gpu-operator
│        2. Increase timeout: Add --timeout 15m to helm install
│        3. Or install without --wait and monitor manually:
│           helm install --generate-name -n gpu-operator --create-namespace nvidia/gpu-operator
│        4. Monitor: kubectl get pods -n gpu-operator -w
│        5. Check logs: kubectl describe pods -n gpu-operator | grep -A5 "Events"
│
├─ ERROR: "ServiceAccount exists and cannot be imported"
│  └─ SOLUTION: Previous installation attempt left resources behind
│     └─ ACTION (RECOMMENDED):
│        1. Delete namespace: kubectl delete namespace gpu-operator
│        2. Recreate namespace: kubectl create namespace gpu-operator
│        3. Retry installation
│     └─ ALTERNATIVE:
│        1. List releases: helm list -n gpu-operator
│        2. Uninstall: helm uninstall <release-name> -n gpu-operator
│        3. If still stuck, use namespace deletion method above
│
├─ ERROR: Pods stuck in "Pending" state
│  └─ ERROR MESSAGE: "0/1 nodes are available: 1 node(s) had untolerated taint"
│     └─ SOLUTION: Pods need tolerations for control-plane taint
│        └─ ACTION:
│           1. Get release name: helm list -n gpu-operator -q | head -1
│           2. Create values file with tolerations (see Step 7 for full example)
│           3. Upgrade: helm upgrade <release-name> -n gpu-operator -f gpu-operator-values.yaml nvidia/gpu-operator
│           4. Verify: kubectl get pods -n gpu-operator
│        └─ ALTERNATIVE (single-node dev only):
│           Remove taint: kubectl taint nodes --all node-role.kubernetes.io/control-plane-
│
└─ SUCCESS: All pods running
   └─ VERIFY:
      1. Check pods: kubectl get pods -n gpu-operator
      2. Check node labels: kubectl get nodes -L nvidia.com/gpu.product
      3. Test GPU: kubectl run gpu-test --image=nvidia/cuda:12.9.0-base-ubuntu22.04 --rm -it --restart=Never -- nvidia-smi

Wann Sie den Support kontaktieren sollten

Kontaktieren Sie support@basebox.ai, wenn:

  • die Installation trotz der Troubleshooting-Schritte scheitert
  • Ihre Hardwarekonfiguration nicht dem Standard entspricht
  • Sie Unterstützung für abgeschottete/Offline-Installationen brauchen
  • Fehler auftreten, die dieser Leitfaden nicht abdeckt
  • Sie Hinweise zu individuellen Konfigurationen brauchen
  • Ihre Organisation besondere Sicherheits- oder Compliance-Anforderungen hat

Geben Sie bei der Kontaktaufnahme folgende Informationen an:

# System Information
uname -a
lsb_release -a
lscpu | grep "Model name"
free -h
df -h

# GPU Information
lspci | grep -i nvidia
nvidia-smi

# Software Versions
nvcc --version
docker --version
kubectl version --client (if applicable)

# Logs (if applicable)
sudo journalctl -u docker -n 100
kubectl logs -n gpu-operator <pod-name> (if applicable)

Nächste Schritte: Deployment

Im Bare-Metal-Pfad geht es weiter mit Schritt 3 · NVIDIA / GPU und Schritt 4 · Kubernetes, danach mit Schritt 7 · basebox installieren.

Kubernetes-Deployment – empfohlene Produktionsmethode

Für alle Produktiv-Deployments Kubernetes verwenden:

Das Kubernetes-Deployment beschreibt der Kubernetes-/Helm-Installationsleitfaden. Er enthält detaillierte Anweisungen zu:

  • Deployment aller basebox-Dienste mit Helm-Charts
  • Konfiguration der GPU-Ressourcenzuteilung je Dienst
  • Einrichtung von Ingress, TLS-Zertifikaten und Netzwerk
  • Produktionsreifem Monitoring und Logging

Voraussetzungen:

  • Kubernetes-Cluster (1.33+) mit installiertem GPU Operator
  • Helm 3.x installiert
  • Zugang zur basebox-Container-Image-Registry während der Installation
  • Für abgeschottete Deployments: support@basebox.ai für Offline-Image-Transfer kontaktieren
  • Storage Class für persistente Volumes konfiguriert

Vorteile:

  • Automatische Skalierung und Lastverteilung
  • Rolling Updates ohne Ausfallzeit
  • Ressourcenisolierung und Sicherheit
  • Produktionsreifes Monitoring und Logging
  • Unterstützung für Multi-Node-Cluster

Docker-basiertes Deployment

Für Entwicklung/Tests:

  • support@basebox.ai für Hinweise zum Docker-basierten Deployment kontaktieren
  • Geeignet für Einzelserver-Entwicklungsumgebungen
  • Für Produktiv-Workloads nicht empfohlen

Beispiele für GPU-Konfigurationen

basebox unterstützt verschiedene GPU-Konfigurationen. Nach der Servervorbereitung konfigurieren Sie die GPU-Zuteilung passend zu Ihrer Hardware:

Einzelne GPU (1x H100, 1x L4 etc.)

  • GPU dem Inferenzdienst zuteilen
  • RAG-Server im CPU-Modus betreiben
  • Geeignet für: Tests, Produktion mit geringem Volumen

Mehrere GPUs (4x H100, 4x L40S, 2x RTX 4090, 2x L40)

  • Alle GPUs dem Inferenzdienst für Tensor-Parallelismus zuteilen
  • RAG-Server im CPU-Modus betreiben
  • Geeignet für: Produktiv-Workloads, hohe Parallelität

Gemischte Konfiguration

  • Primäre GPUs der Inferenz widmen
  • Optional eine GPU dem RAG für OCR-Workloads zuteilen
  • Geeignet für: Produktion mit Dokumentverarbeitung

Hinweis: Die konkrete GPU-Zuteilung und Modellauswahl behandelt der basebox-Deployment-Leitfaden. Kontaktieren Sie support@basebox.ai für Hinweise zur Konfiguration Ihrer Hardware.

Siehe: LLM-Empfehlungen für weitere Details.

Sicherheitsaspekte

Erste Serverhärtung:

# Configure automatic security updates
sudo apt-get install -y unattended-upgrades
sudo dpkg-reconfigure -plow unattended-upgrades

# Configure firewall
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow ssh
sudo ufw enable

# Disable root login via SSH (edit /etc/ssh/sshd_config)
# Set: PermitRootLogin no
sudo nano /etc/ssh/sshd_config
sudo systemctl restart sshd

# Set up SSH key authentication (disable password auth if desired)
# Set in /etc/ssh/sshd_config: PasswordAuthentication no

# Install fail2ban for intrusion prevention
sudo apt-get install -y fail2ban
sudo systemctl enable fail2ban
sudo systemctl start fail2ban

Container-Sicherheit:

  • Non-Root-Benutzer in Containern verwenden
  • Container-Images auf Schwachstellen scannen
  • Container-Capabilities begrenzen
  • Wo möglich schreibgeschützte Dateisysteme nutzen
  • Network Policies in Kubernetes umsetzen

Zugriffskontrolle:

  • BeyondTrust PRA oder vergleichbares Privileged Access Management nutzen
  • Prinzip der minimalen Rechte umsetzen
  • Audit-Logging aktivieren
  • Regelmäßige Sicherheitsupdates

Weitere Sicherheitsressourcen:

Wartung und Updates

Regelmäßige Wartungsaufgaben:

# Update system packages (monthly or as needed)
sudo apt update && sudo apt upgrade -y

# Update NVIDIA drivers (when needed, test in non-production first)
sudo apt update
sudo apt install --upgrade nvidia-driver-550

# Update Docker (when new versions available)
sudo apt update
sudo apt install --upgrade docker-ce docker-ce-cli containerd.io

# Update Kubernetes (if installed, follow upgrade path carefully)
# See: https://kubernetes.io/docs/tasks/administer-cluster/kubeadm/kubeadm-upgrade/

# Clean up unused packages and images
sudo apt autoremove -y
docker system prune -a --volumes  # Use with caution - removes unused data

Monitoring:

  • GPU-Temperatur und -Auslastung überwachen: nvidia-smi -l 1
  • Systemressourcen prüfen: htop, df -h, free -h
  • Docker-Container überwachen: docker stats
  • Kubernetes überwachen (falls genutzt): kubectl top nodes, kubectl top pods

Monitoring-Werkzeuge:

Support und Ressourcen

Offizielle Dokumentation:

basebox-Support:

  • E-Mail: support@basebox.ai
  • Für: Deployment-Unterstützung, abgeschottete Installationen, individuelle Konfigurationen, Fehlersuche

Community-Support:

Fazit

Dieser Leitfaden beschreibt den empfohlenen Weg zur Vorbereitung eines Servers für das basebox-Deployment. Ubuntu 24.04 LTS ist das empfohlene Betriebssystem für Neuinstallationen; ausschlaggebend sind NVIDIA-CUDA-Unterstützung, Docker-/Kubernetes-Kompatibilität, Sicherheit und Wartbarkeit für GPU-beschleunigte KI-Inferenz-Workloads.

Ubuntu 22.04 LTS wird für bestehende Systeme unterstützt. Alternative Linux-Distributionen funktionieren möglicherweise, erfordern aber zusätzliche Konfiguration und sind nicht offiziell unterstützt. Microsoft Windows Server ist wegen der Linux-Anforderung von vLLM und der begrenzten GPU-Container-Unterstützung für basebox nicht geeignet.

Das Wichtigste:

  • Ubuntu 24.04 LTS ist das empfohlene OS für Neuinstallationen
  • CUDA 13.0 erforderlich (12.9 als Rückfalloption)
  • Kubernetes 1.33+ für Produktiv-Deployments erforderlich
  • GPU Compute Capability 7.0+ erforderlich
  • Abgeschottete Deployments mit Unterstützung möglich

Bereit zum Deployment?

Weiter mit Schritt 3 · NVIDIA / GPU. Bei abweichender Umgebung oder abgeschottetem Betrieb unterstützt Sie support@basebox.ai.

Versionshistorie des Dokuments:

  • v2.1.4 (10. Februar 2026): Helm-GPU-Operator korrigiert, Helm-Troubleshooting ergänzt, genaue Testumgebung festgehalten.
  • v2.1.3 (9. Februar 2026): K8S-Schritt 7 korrigiert, CNI-Versionen aktualisiert, Versionsmatrix am Anfang ergänzt, Troubleshooting-Teil ergänzt.
  • v2.1.2 (6. Februar 2026): Helm vor k8s installieren, offizielle Dokumentation zuerst!
  • v2.1.1 (5. Februar 2026): Schritt 5 aktualisiert – globales NVIDIA-Repository nutzen
  • v2.1 (3. Februar 2026): Geprüft, bereinigt, vereinfacht und poliert
  • v2.0 (3. Februar 2026): CUDA-Anforderungen und Kubernetes-Versionen aktualisiert, Schnellstart- und Troubleshooting-Abschnitte ergänzt
  • v1.0 (Erstveröffentlichung): Grundlegender Servervorbereitungsleitfaden

Feedback: Dokumentations-Feedback an support@basebox.ai

Zurück: Voraussetzungen · Weiter: NVIDIA / GPU