SGLang

Déployez SGLang pour la mise en service LLM haute performance avec RadixAttention sur les GPU Clore.ai

SGLang (Structured Generation Language) est un framework haute performance de service de LLM développé par l'équipe LMSYS, connue pour son travail sur Vicuna et Chatbot Arena. Il intègre RadixAttention pour le partage du cache KV, une prise en charge efficace de MoE (Mixture of Experts) et une API compatible avec 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 la place de marché CLORE.AI.

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 les 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	GPU à utiliser

Configuration étape par étape

1. Louez un serveur GPU sur CLORE.AI

Visitez la place de marché CLORE.AI et sélectionnez un serveur :

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

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

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

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

2. Connectez-vous en SSH à votre serveur

ssh -p <PORT> root@<SERVER_IP>

3. Téléchargez l'image Docker de SGLang

docker pull lmsysorg/sglang:latest

4. Lancez le serveur SGLang

Lancement de base (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 un 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 l'état du serveur

# Voir les logs
docker logs -f sglang

# Vérification de l'état (attendre environ 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édez depuis l'extérieur via le proxy CLORE.AI

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

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

Utilisez cette URL comme URL de base dans n'importe quel client compatible OpenAI.

---

Exemples d'utilisation

Exemple 1 : complétions de chat 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

# Pointe vers votre serveur SGLang CLORE.AI
client = OpenAI(
    base_url="http://localhost:30000/v1",
    api_key="none",  # SGLang ne nécessite 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": "L'avenir de l'IA est",
        "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": "Extraire les informations : John Smith, 35 ans, vit à 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

Paramètres de lancement clés

Paramètre	Par défaut	Description
--model-path	requis	ID de 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 (nb de GPU)
--dp	1	Degré de parallélisme des 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 max de jetons en une seule étape de préremplissage
--context-length	max du modèle	Remplacer la longueur maximale du contexte
--trust-remote-code	false	Autoriser le code personnalisé du modèle
--quantization	none	awq, gptq, fp8
--load-format	auto	auto, pt, safetensors
--tokenizer-path	identique au modèle	Chemin personnalisé du tokenizer

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é

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

• Chatbots avec de longs prompts système

• Applications RAG avec contexte répété

• Appels API par lot partageant le même préfixe

Aucune configuration supplémentaire n'est 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 aller trop haut — laissez de la place pour les poids du modèle.

3. Préremplissage par blocs pour les contextes longs

--chunked-prefill-size 4096  # Traiter les prompts longs par blocs

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 GPU

Chaque GPU doit avoir suffisamment de VRAM pour une partition du modèle.

6. Ajuster pour le débit vs la latence

Faible latence (utilisateur unique) :

--max-running-requests 4

Débit élevé (nombreux utilisateurs) :

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

---

Dépannage

Problème : "torch.cuda.OutOfMemoryError"

torch.cuda.OutOfMemoryError : mémoire CUDA insuffisante

Solution : Réduisez la fraction mémoire ou utilisez 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"

Ajoutez --trust-remote-code à la commande de lancement pour les modèles avec des 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 GPU si disponible

Problème : erreurs de longueur de contexte

# Remplacer la longueur du 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

• la place de marché CLORE.AI

---

Recommandations GPU Clore.ai

Cas d’utilisation	GPU recommandé	Coût estimé sur Clore.ai
Développement/Test	RTX 3090 (24 Go)	0,07–0,21 $/gpu/h
Production (7B–13B)	RTX 4090 (24 Go)	0,14–0,42 $/gpu/h
Grands modèles (70B+)	A100 80 Go / H100	~1,04 $/gpu/h

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