Bereite eine Token-Fabrik auf Windows Server aus

Eine token factory ist ein modellbasiertes System mit künstlicher Intelligenz (KI), das Text oder Code als Antwort auf Anwendungsanfragen generiert. Wenn Sie eine lokal ausführen, können Sie KI-unterstützte Anwendungsszenarien bewerten, ohne Prompts an einen gehosteten Modelldienst zu senden.

In diesem Artikel deployen Qwen/Qwen3-Coder-30B-A3B-Instruct Sie mit vLLM auf Windows Server 2025 und validieren den resultierenden, OpenAI-kompatiblen Endpunkt. Die getestete Konfiguration verwendet Ubuntu 24.04 auf Windows-Subsystem für Linux (WSL) 2 und eine NVIDIA RTX PRO 6000 GPU. Das Verfahren erstellt einen Endpunkt, den Sie manuell für Labor- und Testnutzung betreiben; es konfiguriert keinen Produktionszugriff, keine Authentifizierung, keine Fernvernetzung oder den automatischen Start.

Diagramm, das eine Anwendung zeigt, die auf Windows Server 2025 einen lokalen Qwen3-Coder-Endpunkt mit WSL 2, Ubuntu, vLLM und einer RTX PRO 6000 GPU verwendet.

Ein OpenAI-kompatibler API-Client sendet eine Anwendungsanfrage an den lokalen Endpunkt unter 127.0.0.1:8000 und erhält eine Endpunktantwort. Auf dem Endpunkt läuft vLLM mit Qwen3-Coder 30B in Ubuntu 24.04, das in WSL 2 auf Windows Server 2025 läuft. vLLM sendet Modell-Inferenzarbeiten an eine NVIDIA RTX PRO 6000 GPU.

Voraussetzungen

  • Windows Server 2025 und ein Konto mit Administratorrechten.
  • Abschluss der Installation des Linux-Subsystems auf Windows Server. Installiere Ubuntu 24.04 als Ubuntu-24.04 und konfiguriere es so, dass es WSL 2 verwendet.
  • Eine NVIDIA RTX PRO 6000 Blackwell-GPU mit 96 GB GPU-Speicher.
  • Ein NVIDIA Windows-Treiber, der mit CUDA 13.0 kompatibel ist. Installiere den Treiber unter Windows, nicht unter WSL.
  • Ein Konto, das in Ubuntu verwendet sudo werden kann.
  • Internetzugang aus Ubuntu auf die Ubuntu-, NVIDIA-, Astral-, PyTorch-, vLLM- und Hugging Face-Ressourcen, die bei diesem Verfahren verwendet werden.
  • Zugriff auf das Qwen/Qwen3-Coder-30B-A3B-Instruct Modell-Repository auf Hugging Face, Akzeptanz aller geltenden Lizenzbedingungen und alle Anmeldedaten, die der Repository-Host verlangt. Führe alle erforderlichen Authentifizierungen in Ubuntu durch, bevor du mit vLLM startest. Speichern Sie Ihre Zugangsdaten gemäß der Richtlinie Ihrer Organisation zur Geheimhaltung.

Important

Installiere keinen Linux-NVIDIA-Kerneltreiber, Display-Treiber oder Treiber-Metapaket in WSL. WSL verwendet den NVIDIA-Treiber, den Windows bereitstellt.

Überprüfen Sie den Windows Server-Host

Bevor du die Linux-Komponenten installierst, bestätige das Betriebssystem, die WSL-Distribution und die GPU.

  1. Bestätigen Sie in PowerShell die Windows Server-Version:

    Get-ComputerInfo -Property WindowsProductName, WindowsVersion, OsBuildNumber |
        Format-List
    

    Stellen Sie sicher, dass WindowsProductName Windows Server 2025 erkennt.

  2. Bestätigen Sie, dass Ubuntu-24.04 WSL 2 verwendet:

    wsl --list --verbose
    

    Der Ubuntu-24.04 Eintrag muss die Version 2zeigen.

  3. Zeigen Sie die installierte GPU, den GPU-Speicher und die Windows-Treiberversion:

    nvidia-smi --query-gpu=name,memory.total,driver_version --format=csv
    

    Stellen Sie sicher, dass der Ausgang eine NVIDIA RTX PRO 6000 GPU mit etwa 96 GB Speicher anzeigt. Der gemeldete Speicher kann sich leicht von der nominalen Kapazität unterscheiden.

  4. Öffne die Ubuntu-Distribution.

    wsl --distribution Ubuntu-24.04
    
  5. In Ubuntu bestätigen Sie die Distributionsversion, überprüfen Sie sudo den Zugriff und prüfen Sie den verfügbaren Speicher:

    grep PRETTY_NAME /etc/os-release
    sudo -v
    df -h "$HOME"
    

    Stellen Sie sicher, dass das Betriebssystem Ubuntu 24.04 ist. Überprüfen Sie den verfügbaren Speicherplatz für das Heim-Dateisystem.

Führe die restlichen Installations- und Serving-Befehle in Ubuntu aus, es sei denn, ein Schritt spezifiziert PowerShell.

Installiere CUDA 13.0 und vLLM

Dieses Setup installiert CUDA 13.0, Python 3.12, vLLM 0.30.0 und Transformers 5.15.0. Für jede Einrichtungsaufgabe wählen Sie Geführtes Setup für kleinere Befehlsgruppen oder Schnelle Einrichtung für komprimierte Befehlsblöcke.

CUDA 13.0 installieren

  1. Aktualisieren Sie den Ubuntu-Paketindex und installieren Sie die Werkzeuge zur Konfiguration des NVIDIA-Paket-Repositorys:

    sudo apt-get update
    sudo apt-get install -y --no-install-recommends curl ca-certificates
    
  2. Laden Sie den NVIDIA-CUDA-Repository-Schlüsselring herunter und installieren Sie ihn.

    curl -fSL \
        https://developer.download.nvidia.com/compute/cuda/repos/wsl-ubuntu/x86_64/cuda-keyring_1.1-1_all.deb \
        -o /tmp/cuda-keyring.deb
    sudo dpkg -i /tmp/cuda-keyring.deb
    sudo apt-get update
    
  3. Installieren Sie die Komponenten des CUDA 13.0 Toolkits:

    sudo apt-get install -y --no-install-recommends \
        cuda-nvcc-13-0 cuda-cccl-13-0 cuda-cudart-dev-13-0 cuda-crt-13-0 \
        cuda-nvrtc-dev-13-0 cuda-driver-dev-13-0 libcublas-dev-13-0 \
        libcurand-dev-13-0
    

    Das cuda-driver-dev-13-0 Paket stellt Entwicklungsdateien bereit. Es installiert keinen Linux-Display-Treiber.

  4. Setze die CUDA-Umgebungsvariablen für die aktuelle Shell und verifiziere den Compiler.

    export CUDA_HOME=/usr/local/cuda-13.0
    export PATH="$CUDA_HOME/bin:/usr/lib/wsl/lib:$PATH"
    nvcc --version
    

    Bestätigen Sie, dass die Ausgabe CUDA 13.0 identifiziert.

Installation von Python und vLLM

  1. Installiere die Linux-Pakete, die die Python-Umgebung und vLLM benötigen:

    sudo apt-get install -y --no-install-recommends \
        build-essential python3.12-dev python3.12-venv \
        libnuma1 libtcmalloc-minimal4
    
  2. Laden Sie das Installationsskript uv herunter:

    curl -fSL https://astral.sh/uv/install.sh -o /tmp/install-uv.sh
    
  3. Überprüfen Sie /tmp/install-uv.sh gemäß der Softwareinstallationsrichtlinie Ihrer Organisation.

  4. Nach Überprüfung des Installationsprogramms führen Sie es aus, fügen Sie uv zu PATH hinzu und erstellen sowie aktivieren Sie eine Python 3.12-Umgebung:

    sh /tmp/install-uv.sh
    export PATH="$HOME/.local/bin:$PATH"
    uv venv --python 3.12 --python-preference only-system "$HOME/vllm-env"
    source "$HOME/vllm-env/bin/activate"
    
  5. Installieren Sie die folgenden vLLM- und Transformers-Versionen aus den CUDA 13.0-Paketindizen:

    uv pip install --python "$VIRTUAL_ENV/bin/python" \
        vllm==0.30.0 transformers==5.15.0 \
        --extra-index-url https://wheels.vllm.ai/0.30.0/cu130 \
        --extra-index-url https://download.pytorch.org/whl/cu130 \
        --index-strategy unsafe-first-match
    

    Wenn der Befehl fehlerfrei ausgeht, ist die Installation erfolgreich gewesen.

Konfigurieren und starten Sie den Modellserver

Starte vLLM im Vordergrund, um dessen Status und Ausgabe zu überwachen.

  1. In der Ubuntu-Shell legen Sie nach der Aktivierung von vllm-env einen persistenten Speicherort für heruntergeladene Modelldateien fest:

    export HF_HOME="$HOME/hf-cache"
    
  2. Starte den Endpunkt.

    vllm serve Qwen/Qwen3-Coder-30B-A3B-Instruct \
        --host 127.0.0.1 \
        --port 8000 \
        --max-model-len 32768
    
  3. Halte das Terminal offen, bis vLLM meldet, dass der Server bereit ist.

Der erste Start lädt die Modelldateien nach HF_HOME herunter und lädt das Modell. Der Endpunkt verwendet eine GPU und begrenzt den kombinierten Eingabe- und Ausgabekontext auf 32.768 Tokens. Diese Begrenzung lässt GPU-Speicher für den Laufzeit-Overhead und den Key-Value-Cache verfügbar.

Important

Dieser Endpunkt verwendet keine Authentifizierung. Die Bindung an 127.0.0.1 begrenzt die Netzwerkexposition, aber es ist keine Authentifizierungsgrenze. Prozesse, die den WSL-Loopback-Endpunkt erreichen können, können Anfragen senden. Verwenden Sie diese Konfiguration nur auf einem vertrauenswürdigen, zugriffsgesteuerten Host. Stellen Sie den Endpunkt nicht einem Netzwerk ohne genehmigte Authentifizierung, TLS, Firewall und Zugriffskontrolle zur Verfügung.

Parameter und Einstellungen für die Modellbereitstellung

Parameter Vorgabe Wann man sie einsetzen sollte
--tensor-parallel-size 1 Der Standardwert ist 1. Nutze es, um explizit das Single-GPU-Serving zu dokumentieren.
--port 8000 Der Standardport ist 8000. Verwende es, wenn du einen anderen Port auswählst, und aktualisiere alle Client-URLs.
--enable-auto-tool-choice Standardmäßig deaktiviert. Ermöglicht die automatische Werkzeugauswahl für kompatible Agentenanwendungen.
--tool-call-parser qwen3_coder Nicht standardmäßig festgelegt. Wählt den Qwen3-Coder Werkzeugaufruf-Parser für die automatische Werkzeugwahl aus.

Validiere den Modellserver

Verwenden Sie PowerShell, um die Modelle aufzulisten, die der Endpunkt bedient, und überprüfen Sie dann, ob das ausgewählte Qwen-Modell eine Antwort generiert.

  1. Lasse das Ubuntu-Terminal, das vLLM ausführt, offen.

  2. Öffnen Sie ein zweites PowerShell-Fenster und setzen Sie die Endpunkt-URL:

    $inferenceBaseUrl = 'http://127.0.0.1:8000'
    
  3. Listen Sie die Modelle auf, die vom Endpunkt bereitgestellt werden:

    $models = Invoke-RestMethod `
        -Uri "$inferenceBaseUrl/v1/models" `
        -TimeoutSec 30 `
        -ErrorAction Stop
    $models.data | Select-Object id
    

    Bestätigen Sie, dass die Ausgabe Qwen/Qwen3-Coder-30B-A3B-Instruct enthält.

  4. Erstellen Sie eine Anfrage für Chat Completions:

    $body = @{
        model = 'Qwen/Qwen3-Coder-30B-A3B-Instruct'
        messages = @(
            @{
                role = 'user'
                content = 'When is the last sunset in the Nordic region. Give a short answer.'
            }
        )
        max_tokens = 32
    } | ConvertTo-Json -Depth 5
    
  5. Senden Sie die Anfrage und zeigen Sie die generierten Inhalte:

    $response = Invoke-RestMethod `
        -Uri "$inferenceBaseUrl/v1/chat/completions" `
        -Method Post `
        -ContentType 'application/json' `
        -Body $body `
        -TimeoutSec 120 `
        -ErrorAction Stop
    
    $response.choices[0].message.content
    

    Bestätigen Sie, dass die generierte Antwort nicht leer und relevant für die Eingabeaufforderung ist. Die Modellgenerierung und nicht die faktische Überprüfung der Antwort ist der End-to-End-Test.