SGLang

Déployer SGLang pour un service LLM haute performance avec RadixAttention sur les GPU Clore.ai

SGLang (Structured Generation Language) est un cadre de service LLM haute performance développé par l'équipe LMSYS, connue pour leurs travaux sur Vicuna et Chatbot Arena. Il intègre RadixAttention pour le partage du cache KV, prend en charge efficacement MoE (Mixture of Experts) et propose une API compatible OpenAI — ce qui en fait l'un des moteurs d'inférence open-source les plus rapides disponibles sur les serveurs GPU de CLORE.AI.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

Exigences du serveur

Paramètre	Minimum	Recommandé
RAM	16 Go	32 Go+
VRAM	8 Go	24 Go+
Disque	50 Go	200 Go+
GPU	NVIDIA Turing+ (RTX 2000+)	A100, H100, RTX 4090

SGLang obtient ses meilleures performances sur les GPU Ampere+ avec FlashInfer activé. Pour les modèles MoE comme Mixtral ou DeepSeek, des configurations multi-GPU sont recommandées.

Déploiement rapide sur CLORE.AI

Image Docker : lmsysorg/sglang:latest

Ports : 22/tcp, 30000/http

Variables d'environnement :

Variable	Exemple	Description
HF_TOKEN	hf_xxx...	Jeton HuggingFace pour les modèles protégés
CUDA_VISIBLE_DEVICES	0,1	GPUs à utiliser

Configuration étape par étape

1. Louez un serveur GPU sur CLORE.AI

Visitez CLORE.AI Marketplace et sélectionnez un serveur :

• Modèles 7B: minimum 16 Go de VRAM (RTX 4080, A10)

• Modèles 13B: 24 Go de VRAM (RTX 3090, RTX 4090, A5000)

• Modèles 70B: 80 Go+ de VRAM (A100 80GB) ou multi-GPU

• Modèles MoE (Mixtral 8x7B): 48 Go de VRAM ou 2× 24 Go

2. SSH sur votre serveur

ssh -p <PORT> root@<SERVER_IP>

3. Récupérez l'image Docker SGLang

docker pull lmsysorg/sglang:latest

4. Lancez le serveur SGLang

Lancement basique (Llama 3.1 8B) :

docker run -d \
  --name sglang \
  --gpus all \
  --shm-size 16g \
  --ipc host \
  -p 30000:30000 \
  -v /root/models:/root/.cache/huggingface \
  lmsysorg/sglang:latest \
  python3 -m sglang.launch_server \
    --model-path meta-llama/Meta-Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --port 30000

Avec le jeton HuggingFace :

docker run -d \
  --name sglang \
  --gpus all \
  --shm-size 16g \
  --ipc host \
  -p 30000:30000 \
  -v /root/models:/root/.cache/huggingface \
  -e HF_TOKEN=hf_your_token_here \
  lmsysorg/sglang:latest \
  python3 -m sglang.launch_server \
    --model-path meta-llama/Meta-Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --port 30000 \
    --dtype bfloat16

Qwen2.5 72B sur multi-GPU :

docker run -d \
  --name sglang \
  --gpus all \
  --shm-size 32g \
  --ipc host \
  -p 30000:30000 \
  -v /root/models:/root/.cache/huggingface \
  lmsysorg/sglang:latest \
  python3 -m sglang.launch_server \
    --model-path Qwen/Qwen2.5-72B-Instruct \
    --host 0.0.0.0 \
    --port 30000 \
    --tp 2 \
    --dtype bfloat16

DeepSeek-V2 (modèle MoE) :

docker run -d \
  --name sglang \
  --gpus all \
  --shm-size 32g \
  --ipc host \
  -p 30000:30000 \
  -v /root/models:/root/.cache/huggingface \
  lmsysorg/sglang:latest \
  python3 -m sglang.launch_server \
    --model-path deepseek-ai/DeepSeek-V2-Lite-Chat \
    --host 0.0.0.0 \
    --port 30000 \
    --trust-remote-code \
    --tp 1

5. Vérifiez la santé du serveur

# Voir les logs
docker logs -f sglang

# Vérification de santé (attendre ~2-3 minutes pour le chargement du modèle)
curl http://localhost:30000/health

# Obtenir les informations du modèle
curl http://localhost:30000/get_model_info

6. Accès externe via le proxy CLORE.AI

Votre tableau de bord CLORE.AI fournit un http_pub URL pour le port 30000 :

https://<order-id>-30000.clore.ai/

Utilisez cette URL comme URL de base dans tout client compatible OpenAI.

---

Exemples d'utilisation

Exemple 1 : Chat Completions compatibles OpenAI

curl http://localhost:30000/v1/chat/completions \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "meta-llama/Meta-Llama-3.1-8B-Instruct",
    "messages": [
      {"role": "system", "content": "You are a helpful coding assistant."},
      {"role": "user", "content": "Write a quicksort implementation in Python."}
    ],
    "max_tokens": 512,
    "temperature": 0.2
  }'

Exemple 2 : Réponse en streaming

curl http://localhost:30000/v1/chat/completions \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "meta-llama/Meta-Llama-3.1-8B-Instruct",
    "messages": [
      {"role": "user", "content": "Explain how transformer attention works."}
    ],
    "max_tokens": 800,
    "stream": true
  }' \
  --no-buffer

Exemple 3 : Client Python OpenAI

from openai import OpenAI

# Pointez vers votre serveur SGLang CLORE.AI
client = OpenAI(
    base_url="http://localhost:30000/v1",
    api_key="none",  # SGLang n'exige pas d'authentification par défaut
)

response = client.chat.completions.create(
    model="meta-llama/Meta-Llama-3.1-8B-Instruct",
    messages=[
        {"role": "system", "content": "You are a data science expert."},
        {"role": "user", "content": "What is gradient boosting?"},
    ],
    max_tokens=400,
    temperature=0.7,
)

print(response.choices[0].message.content)

Exemple 4 : Inférence par lot avec l'API native SGLang

L'API native de SGLang offre un contrôle supplémentaire :

import requests

# Générer des complétions
response = requests.post(
    "http://localhost:30000/generate",
    json={
        "text": "The future of AI is",
        "sampling_params": {
            "max_new_tokens": 200,
            "temperature": 0.8,
            "top_p": 0.95,
        },
    },
)
print(response.json()["text"])

Exemple 5 : Sortie JSON contrainte

SGLang prend en charge la génération de sorties structurées :

import requests

schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "integer"},
        "city": {"type": "string"},
    },
    "required": ["name", "age", "city"],
}

response = requests.post(
    "http://localhost:30000/generate",
    json={
        "text": "Extract information: John Smith, 35 years old, lives in New York.",
        "sampling_params": {
            "max_new_tokens": 100,
            "temperature": 0.0,
        },
        "json_schema": schema,
    },
)
print(response.json()["text"])
# Sortie : {"name": "John Smith", "age": 35, "city": "New York"}

---

Configuration

Principaux paramètres de lancement

Paramètre	Par défaut	Description
--model-path	requis	ID du modèle HuggingFace ou chemin local
--host	127.0.0.1	Hôte de liaison (utiliser 0.0.0.0 pour l'externe)
--port	30000	Port du serveur
--tp	1	Degré de parallélisme tensoriel (nombre de GPUs)
--dp	1	Degré de parallélisme de données
--dtype	auto	float16, bfloat16, float32
--mem-fraction-static	0.88	Fraction de la VRAM pour le cache KV
--max-prefill-tokens	auto	Nombre maximal de tokens dans une étape de pré-remplissage
--context-length	max du modèle	Remplacer la longueur de contexte maximale
--trust-remote-code	false	Autoriser le code personnalisé du modèle
--quantization	aucune	awq, gptq, fp8
--load-format	auto	auto, pt, safetensors
--tokenizer-path	identique au modèle	Chemin du tokenizer personnalisé

Options de quantification

AWQ (recommandé pour la vitesse) :

python3 -m sglang.launch_server \
  --model-path casperhansen/mistral-7b-instruct-v0.2-awq \
  --quantization awq \
  --host 0.0.0.0 \
  --port 30000

FP8 (pour H100/A100) :

python3 -m sglang.launch_server \
  --model-path meta-llama/Meta-Llama-3.1-8B-Instruct \
  --quantization fp8 \
  --host 0.0.0.0 \
  --port 30000

---

Conseils de performance

1. RadixAttention — L'avantage clé

La RadixAttention de SGLang réutilise automatiquement le cache KV pour les préfixes d'invite partagés. Cela est particulièrement puissant pour :

• Chatbots avec de longues instructions système

• Applications RAG avec contexte répété

• Appels d'API en lot partageant le même préfixe

Aucune configuration supplémentaire nécessaire — c'est toujours activé.

2. Augmenter la taille du cache KV

--mem-fraction-static 0.90  # Utiliser 90% de la VRAM pour le cache KV

Faites attention à ne pas trop augmenter — laissez de la place pour les poids du modèle.

3. Pré-remplissage en morceaux pour les contextes longs

--chunked-prefill-size 4096  # Traiter les invites longues par morceaux

4. Activer le backend FlashInfer

SGLang utilise automatiquement FlashInfer lorsqu'il est disponible (GPU Ampere+) :

--attention-backend flashinfer

5. Parallélisme tensoriel multi-GPU

Pour les modèles qui ne tiennent pas sur un seul GPU :

--tp 4  # Utiliser 4 GPUs

Chaque GPU doit avoir suffisamment de VRAM pour une portion (shard) du modèle.

6. Ajuster pour le débit vs la latence

Faible latence (utilisateur unique) :

--max-running-requests 4

Haut débit (plusieurs utilisateurs) :

--max-running-requests 64 \
--schedule-policy lpm  # Ordonnancement Longest Prefix Match

---

Dépannage

Problème : "torch.cuda.OutOfMemoryError"

torch.cuda.OutOfMemoryError : mémoire CUDA insuffisante

Solution : Réduire la fraction de mémoire ou utiliser la quantification :

--mem-fraction-static 0.80
# ou
--quantization awq

Problème : Le serveur ne démarre pas (bloqué au chargement)

# Vérifier la disponibilité de CUDA
docker exec -it sglang nvidia-smi

# Vérifier la progression du téléchargement du modèle
docker logs -f sglang 2>&1 | tail -50

Problème : "trust_remote_code required"

Ajouter --trust-remote-code à la commande de lancement pour les modèles avec architectures personnalisées (DeepSeek, Falcon, etc.).

Problème : Génération lente sur les modèles MoE

Les modèles MoE (Mixtral, DeepSeek) sont limités par la bande passante mémoire. Assurez-vous d'utiliser :

--dtype bfloat16  # Mieux que float16 pour MoE
--tp 2            # Répartir sur plusieurs GPUs si disponible

Problème : Erreurs de longueur de contexte

# Remplacer la longueur de contexte
--context-length 32768

Problème : Le port 30000 n'est pas accessible

Vérifiez que le port est exposé dans la configuration de votre commande CLORE.AI. Consultez l'URL http_pub dans le tableau de bord de votre commande, pas localhost.

---

Liens

• GitHub

• Documentation

• Docker Hub

• Modèles pris en charge

• CLORE.AI Marketplace

---

Recommandations GPU Clore.ai

Cas d'utilisation	GPU recommandé	Coût estimé sur Clore.ai
Développement/Test	RTX 3090 (24GB)	~0,12 $/GPU/heure
Production (7B–13B)	RTX 4090 (24GB)	~0,70 $/GPU/heure
Grands modèles (70B+)	A100 80GB / H100	~1,20 $/GPU/heure

💡 Tous les exemples de ce guide peuvent être déployés sur Clore.ai serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, accès root complet.