Führen Sie einen vLLM-Server auf HF-Jobs mit einem Befehl aus

Einen vLLM-Server mit einem Befehl auf HF Jobs ausführen

Die Bereitstellung großer Sprachmodelle (LLMs) für die Inferenz ist ein entscheidender Schritt vom Experimentieren zur Produktion. Die vLLM-Inferenz-Engine hat sich als leistungsstarkes Werkzeug zur effizienten Bereitstellung von Modellen etabliert, das fortschrittliches Batching und Speicherverwaltung nutzt. Hugging Face Jobs (HF Jobs) bietet eine skalierbare, cloud-native Umgebung zur Ausführung dieser Inferenz-Workloads. Dieser Artikel zeigt Ihnen, wie Sie diese beiden Technologien kombinieren und mit einem einzigen Befehl einen vLLM-Server starten können, um Ihre Bereitstellungspipeline zu optimieren.

Was Sie lernen werden

Am Ende dieses Artikels werden Sie verstehen:

• Wie vLLM die LLM-Inferenz beschleunigt.
• Die Voraussetzungen für die Nutzung von HF Jobs.
• Schritt-für-Schritt-Installation und Konfiguration eines vLLM-Servers.
• Praktische Befehle zum Ausführen des Servers mit einem Befehl.
• Praxisnahe Anwendungsbeispiele und Best Practices.

Hintergrund: vLLM und HF Jobs

**vLLM** ist eine Open-Source-Inferenz-Engine, die für hohen Durchsatz und niedrige Latenz ausgelegt ist. Sie verwendet Techniken wie PagedAttention, um den Key-Value-Cache-Speicher effizient zu verwalten, sodass Sie Modelle wie Llama, Mistral und andere mit minimalem Overhead bereitstellen können.

**Hugging Face Jobs** ist ein verwalteter Dienst, der Ihren Code auf skalierbarer Cloud-Infrastruktur ausführt. Er integriert sich nahtlos in den Hugging Face Hub, sodass Sie Modelle direkt abrufen und Befehle ausführen können, ohne Server selbst verwalten zu müssen. Die Plattform unterstützt GPU-Instanzen und ist daher ideal für LLM-Inferenz.

Die Kombination von vLLM mit HF Jobs bietet ein serverloses Erlebnis: Sie geben ein Modell, einen Befehl und die benötigten Ressourcen an, und die Plattform erledigt den Rest.

Voraussetzungen

Stellen Sie vor dem Fortfahren sicher, dass Folgendes vorhanden ist:

1. **Ein Hugging Face-Konto** – Registrieren Sie sich unter [huggingface.co](https://huggingface.co). Sie benötigen ein Zugriffstoken mit Schreibberechtigungen, um Jobs zu erstellen. 2. **HF CLI installiert** – Installieren Sie die Hugging Face CLI lokal, um mit dem Hub und der Jobs-API zu interagieren. Verwenden Sie `pip install huggingface-hub`. 3. **Ein GPU-kompatibles Modell** – vLLM funktioniert am besten mit Modellen wie Mistral 7B, Llama 2/3 oder jedem Modell, das von Hugging Face Transformers unterstützt wird. Stellen Sie sicher, dass das Modell öffentlich zugänglich ist oder Sie Zugriff haben. 4. **Grundlegende Vertrautheit mit Docker und CLI** – HF Jobs verwendet Docker-Container, und Sie werden Befehle von Ihrem Terminal aus ausführen.

Schritt-für-Schritt-Installation und Konfiguration

1. Einrichten Ihrer Umgebung

Installieren Sie zunächst die Hugging Face CLI und authentifizieren Sie sich:

pip install huggingface-hub
huggingface-cli login

Geben Sie Ihr Zugriffstoken ein, wenn Sie dazu aufgefordert werden. Dieses Token wird lokal gespeichert und für alle nachfolgenden API-Aufrufe verwendet.

2. Die Struktur von HF Jobs verstehen

HF Jobs erfordern eine Job-Definition. Der einfachste Weg ist die Verwendung des `huggingface_hub` Python SDK oder der CLI. Für einen Ein-Befehl-Start verwenden wir direkt die CLI.

Ein Job umfasst typischerweise:

• `--name`: Ein Job-Name.
• `--type`: Der Job-Typ (z. B. `inference`).
• `--image`: Ein Docker-Image mit installiertem vLLM.
• `--command`: Der Befehl, der im Container ausgeführt werden soll.
• `--resources`: GPU-Anforderungen (z. B. `gpu=1`, `memory=16Gi`).

3. Ein Docker-Image auswählen oder erstellen

Sie können das offizielle vLLM-Docker-Image von Docker Hub verwenden oder Ihr eigenes erstellen. Der Einfachheit halber verwenden wir `vllm/vllm-openai:latest`, das den OpenAI-kompatiblen API-Server enthält.

Überprüfen Sie die neueste Version auf dem [vLLM GitHub](https://github.com/vllm-project/vllm) oder verwenden Sie ein bestimmtes Tag wie `v0.4.0`.

4. Einen einfachen Python-Einstiegspunkt schreiben (optional)

Wenn Sie benutzerdefinierte Logik benötigen, können Sie ein Python-Skript schreiben. Für einen Ein-Befehl-Start ist der vLLM-Server selbst der Einstiegspunkt. Der Befehl lautet:

python -m vllm.entrypoints.openai.api_server --model <modellname> --port 8000

5. Den Job mit einem Befehl starten

Kombinieren Sie nun alles zu einem einzigen HF-Jobs-Befehl. Ersetzen Sie `<ihr-modell>` durch die Modell-ID (z. B. `mistralai/Mistral-7B-Instruct-v0.2`).

huggingface-cli jobs create \
  --name vllm-server \
  --type inference \
  --image vllm/vllm-openai:latest \
  --command "python -m vllm.entrypoints.openai.api_server --model mistralai/Mistral-7B-Instruct-v0.2 --port 8000" \
  --resources gpu=1,memory=16Gi

**Erklärung:**

• `--name`: Der Anzeigename Ihres Jobs.
• `--type`: `inference` kennzeichnet einen GPU-Inferenz-Job.
• `--image`: Das Docker-Image mit vLLM und Abhängigkeiten.
• `--command`: Der genaue auszuführende Befehl. Der vLLM-API-Server startet auf Port 8000.
• `--resources`: Fordert eine GPU und 16 GB Arbeitsspeicher an (je nach Modellgröße anpassen).

Nach der Ausführung wird HF Jobs: 1. Das Docker-Image pullen. 2. Eine GPU-Instanz zuweisen. 3. Den Befehl im Container ausführen. 4. Einen Endpunkt bereitstellen (die URL sehen Sie in den Job-Logs).

6. Den Job überwachen

Überprüfen Sie den Job-Status und die Logs:

huggingface-cli jobs logs --name vllm-server

Sobald der Server bereit ist, sehen Sie eine Ausgabe wie `Uvicorn running on http://0.0.0.0:8000`. Die tatsächliche öffentliche URL wird in den Job-Details angegeben.

Anwendungsbeispiele

Beispiel 1: Einfache Textgenerierung

Sobald der Server läuft, können Sie Anfragen an den OpenAI-kompatiblen Endpunkt senden. Verwenden Sie `curl` oder einen beliebigen HTTP-Client:

curl http://<job-url>:8000/v1/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "prompt": "Was ist die Hauptstadt von Frankreich?",
    "max_tokens": 50
  }'

**Antwort:**

{
  "id": "cmpl-...",
  "object": "text_completion",
  "choices": [{"text": " Die Hauptstadt von Frankreich ist Paris."}]
}

Beispiel 2: Chat-Completions

Für chatbasierte Modelle verwenden Sie den `/v1/chat/completions`-Endpunkt:

curl http://<job-url>:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "messages": [
      {"role": "user", "content": "Erklären Sie Quantencomputing in einfachen Worten."}
    ],
    "temperature": 0.7
  }'

Beispiel 3: Skalierung mit mehreren GPUs

Für größere Modelle wie Llama 3 70B benötigen Sie möglicherweise mehrere GPUs. Verwenden Sie Tensor-Parallelismus:

huggingface-cli jobs create \
  --name vllm-llama3 \
  --type inference \
  --image vllm/vllm-openai:latest \
  --command "python -m vllm.entrypoints.openai.api_server --model meta-llama/Meta-Llama-3-70B-Instruct --tensor-parallel-size 4 --port 8000" \
  --resources gpu=4,memory=64Gi

Hier teilt `--tensor-parallel-size 4` das Modell auf 4 GPUs auf.

Beispiel 4: Verwendung von Umgebungsvariablen

Sie können Umgebungsvariablen für die Konfiguration übergeben, z. B. API-Schlüssel oder benutzerdefinierte Einstellungen:

huggingface-cli jobs create \
  --name vllm-custom \
  --type inference \
  --image vllm/vllm-openai:latest \
  --command "python -m vllm.entrypoints.openai.api_server --model mistralai/Mistral-7B-Instruct-v0.2 --port 8000" \
  --resources gpu=1,memory=16Gi \
  --env HF_TOKEN=ihr_token_hier

**Hinweis:** Gehen Sie vorsichtig damit um; Token sind in Job-Logs sichtbar.

Best Practices und Fehlerbehebung

Das richtige Modell auswählen

• **Modellgröße vs. GPU-Speicher:** Ein 7B-Modell passt auf eine einzelne 16-GB-GPU (z. B. T4, V100). 13B-Modelle benötigen ~24 GB. 70B-Modelle erfordern mehrere GPUs.
• **Quantisierung:** Verwenden Sie `--dtype half` oder `--quantization awq` von vLLM, um Speicher zu sparen. Zum Beispiel:

--command "python -m vllm.entrypoints.openai.api_server --model TheBloke/Mistral-7B-Instruct-v0.2-AWQ --quantization awq --port 8000"

Umgang mit Timeouts

Der erste Start kann mehrere Minuten dauern, um das Modell herunterzuladen. Stellen Sie bei Bedarf ein längeres Timeout in Ihrem Client ein.

Sicherheit

• Geben Sie Ihr HF-Token nicht im Job-Befehl preis. Verwenden Sie Umgebungsvariablen oder einen Secrets-Manager.
• Der Server-Endpunkt ist standardmäßig öffentlich. Fügen Sie für die Produktion eine Authentifizierung hinzu (z. B. über einen Reverse-Proxy).

Logs und Fehlerbehebung

Wenn der Job fehlschlägt, überprüfen Sie die Logs:

huggingface-cli jobs logs --name vllm-server --tail 50

Häufige Fehler:

• **Nicht genügend Speicher:** Erhöhen Sie den GPU-Speicher oder verwenden Sie ein kleineres Modell.
• **Modell nicht gefunden:** Stellen Sie sicher, dass die Modell-ID korrekt und zugänglich ist.
• **Portkonflikt:** Ändern Sie den Port mit `--port <neuer-port>`.

Fazit

Das Ausführen eines vLLM-Servers auf HF Jobs mit einem einzigen Befehl vereinfacht die Bereitstellung von LLM-Inferenz-Workloads. Durch die Nutzung der effizienten Engine von vLLM und der verwalteten Infrastruktur von HF Jobs können Sie Modelle wie Mistral und Llama in Minuten bereitstellen, ohne Server verwalten zu müssen. Die wichtigsten Schritte sind:

1. Authentifizieren Sie sich mit der Hugging Face CLI. 2. Verwenden Sie ein vorgefertigtes vLLM-Docker-Image. 3. Schreiben Sie einen prägnanten Befehl, der den API-Server startet. 4. Starten Sie den Job mit GPU-Ressourcen.

Dieser Ansatz eignet sich ideal für Prototyping, Tests und sogar produktionsreife Inferenz, insbesondere in Kombination mit Skalierungsfunktionen wie Tensor-Parallelismus. Während sich das Ökosystem weiterentwickelt – mit Updates von Mistral AI, Meta AI und der Ollama-Community – werden vLLM und HF Jobs zentral für die effiziente Modellbereitstellung bleiben.

Probieren Sie es noch heute aus: Wählen Sie ein Modell, führen Sie den Befehl aus und beginnen Sie in Minuten mit der Textgenerierung.