Deploy large language models on PAI-EAS - Platform For AI - Centre de documentation Alibaba Cloud

PAI-EAS propose une solution complète pour déployer en un clic des modèles de langage de grande taille (LLM) populaires tels que DeepSeek et Qwen. Cela simplifie des tâches complexes telles que la configuration de l'environnement, l'optimisation des performances et la gestion des coûts.

Démarrage rapide : déployer un modèle open source

Cet exemple montre comment déployer le modèle open source Qwen3-8B. La même procédure s'applique aux autres modèles pris en charge.

Étape 1 : Créer un service

Connectez-vous à la console PAI. Sélectionnez une région en haut de la page. Ensuite, choisissez l'espace de travail souhaité et cliquez sur Elastic Algorithm Service (EAS).
Cliquez sur Deploy Service. Dans la zone Scenario-based Model Deployment, cliquez sur LLM Deployment.

Configurez les paramètres clés suivants :

Paramètre

Valeur

Model Settings

Sélectionnez Public Model, puis recherchez et sélectionnez Qwen3-8B.

Inference Engine

Sélectionnez vLLM (recommandé, compatible avec l'API OpenAI).

Deployment Template

Sélectionnez Single-Node. Le système remplit automatiquement les paramètres recommandés, tels que le type d'instance et l'image, sur la base du modèle.

Cliquez sur Deploy. Le déploiement du service prend environ 5 minutes. Lorsque l'état du service passe à Running, le déploiement est réussi.

Remarque
Si le déploiement du service échoue, reportez-vous à la section Problèmes de déploiement et d'état des services pour le dépannage.

Étape 2 : Vérifier le service

Une fois le déploiement terminé, utilisez le débogage en ligne pour vérifier que le service fonctionne correctement.

Cliquez sur le nom du service pour ouvrir sa page de détails, puis basculez vers l'onglet Online Debugging.

Configurez les paramètres de requête suivants :

Paramètre	Valeur
Méthode de requête	POST
Chemin d'URL	Saisissez le chemin d'URL complet au format `/api/predict/{service_name}/v1/chat/completions`, où `{service_name}` correspond au nom de votre service déployé. Exemple : `/api/predict/llm_qwen3_8b_test/v1/chat/completions`.
Corps	`{ "model": "Qwen3-8B", "messages": [ {"role": "user", "content": "Hello!"} ], "max_tokens": 1024 }`
En-têtes	Assurez-vous que la requête inclut `Content-Type: application/json`.

Cliquez sur Send Request. Vous devriez recevoir une réponse contenant la réponse du modèle.

Si la requête renvoie un code d'état 200 et une réponse JSON de type chat.completion, le service est déployé et fonctionne correctement. Le corps de la réponse contient la réponse du modèle dans le champ content.

Appeler l'API

Avant d'appeler le service, accédez à l'onglet View Endpoint Information sur la page de détails du service pour obtenir le point de terminaison et le jeton.

Les exemples suivants montrent comment appeler l'API du service :

cURL

curl -X POST <EAS_ENDPOINT>/v1/chat/completions \
    -H "Content-Type: application/json" \
    -H "Authorization: <EAS_TOKEN>" \
    -d '{
        "model": "<model_name>",
        "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user",
            "content": "hello"
        }
        ],
        "max_tokens":1024,
        "temperature": 0.7,
        "top_p": 0.8,
        "stream":true
    }'

Dans le code précédent, remplacez les paramètres suivants :

Remplacez <EAS_ENDPOINT> et <EAS_TOKEN> par le point de terminaison et le jeton de votre service déployé.
Remplacez <model_name> par le nom du modèle. Pour vLLM ou SGLang, vous pouvez obtenir le nom du modèle à partir de l'API de liste des modèles située à l'adresse <EAS_ENDPOINT>/v1/models.
```
curl -X GET <EAS_ENDPOINT>/v1/models -H "Authorization: <EAS_TOKEN>"
```

OpenAI SDK

Nous vous recommandons d'utiliser le SDK Python officiel pour interagir avec le service. Assurez-vous d'avoir installé le SDK OpenAI : pip install openai.

from openai import OpenAI

# 1. Configure the client.
# Replace <EAS_TOKEN> with the token of your deployed service.
openai_api_key = "<EAS_TOKEN>"
# Replace <EAS_ENDPOINT> with the endpoint of your deployed service.
openai_api_base = "<EAS_ENDPOINT>/v1"

client = OpenAI(
    api_key=openai_api_key,
    base_url=openai_api_base,
)

# 2. Get the model name.
# For BladeLLM, set model = "". BladeLLM does not require a model parameter
# and does not support getting the model name by using client.models.list().
# Set it to an empty string to meet the mandatory parameter requirement of the OpenAI SDK.
models = client.models.list()
model = models.data[0].id
print(model)

# 3. Send a chat request.
# Both streaming (stream=True) and non-streaming (stream=False) outputs are supported.
stream = True
chat_completion = client.chat.completions.create(
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "hello"},          
    ],
    model=model,
    top_p=0.8,
    temperature=0.7,
    max_tokens=1024,
    stream=stream,
)

if stream:
    for chunk in chat_completion:
        print(chunk.choices[0].delta.content, end="")
else:
    result = chat_completion.choices[0].message.content
    print(result)

Python requests

Si vous ne souhaitez pas ajouter de dépendance au SDK OpenAI, vous pouvez utiliser la bibliothèque requests.

import json
import requests

# Replace <EAS_ENDPOINT> with the endpoint of your deployed service.
EAS_ENDPOINT = "<EAS_ENDPOINT>"
# Replace <EAS_TOKEN> with the token of your deployed service.
EAS_TOKEN = "<EAS_TOKEN>"
# Replace <model_name> with the model name. You can get it from the <EAS_ENDPOINT>/v1/models API.
# For BladeLLM, this API is not supported. You can omit the "model" field or set it to "".
model = "<model_name>"

url = f"{EAS_ENDPOINT}/v1/chat/completions"
headers = {
    "Content-Type": "application/json",
    "Authorization": EAS_TOKEN,
}

stream = True
messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "hello"},
]

req = {
    "messages": messages,
    "stream": stream,
    "temperature": 0.7,
    "top_p": 0.8,
    "max_tokens": 1024,
    "model": model,
}
response = requests.post(
    url,
    json=req,
    headers=headers,
    stream=stream,
)

if stream:
    for chunk in response.iter_lines(chunk_size=8192, decode_unicode=False):
        msg = chunk.decode("utf-8")
        # The following code processes Server-Sent Events (SSE) formatted streaming responses.
        if msg.startswith("data:"):
            info = msg[6:]
            if info == "[DONE]":
                break
            else:
                resp = json.loads(info)
                if resp["choices"][0]["delta"].get("content") is not None:
                    print(resp["choices"][0]["delta"]["content"], end="", flush=True)
else:
    resp = json.loads(response.text)
    print(resp["choices"][0]["message"]["content"])

Construire une interface web locale

Gradio est une bibliothèque d'interface utilisateur Python qui vous aide à créer rapidement des interfaces interactives pour les modèles. Suivez ces étapes pour exécuter une interface web Gradio localement.

Télécharger le code

Lien GitHub | Lien OSS
Préparer l'environnement

Python 3.10 ou version ultérieure est requis, et vous devez installer les dépendances en exécutant pip install openai gradio.
Démarrer l'application web

Dans le terminal, exécutez la commande suivante. Remplacez <EAS_ENDPOINT> et <EAS_TOKEN> par le point de terminaison et le jeton du service déployé.
```
python webui_client.py --eas_endpoint "<EAS_ENDPOINT>" --eas_token "<EAS_TOKEN>"
```
Après un démarrage réussi, une URL locale est affichée (généralement http://127.0.0.1:7860). Ouvrez cette URL dans un navigateur pour y accéder.

Intégrer avec des applications tierces

Vous pouvez intégrer un service PAI-EAS avec divers clients et outils de développement prenant en charge l'API OpenAI. Les paramètres de configuration clés sont le point de terminaison du service, le jeton et le nom du modèle.

Dify

Installer le fournisseur de modèle compatible avec l'API OpenAI

Cliquez sur votre avatar dans le coin supérieur droit et sélectionnez Settings. Dans le volet de gauche, sélectionnez Model Providers. Si OpenAI-API-compatible ne figure pas dans la Model List, recherchez-le dans la liste ci-dessous et cliquez sur Install.
Ajouter un modèle

Cliquez sur Add Model dans le coin inférieur droit de la carte OpenAI-API-compatible et configurez les paramètres suivants :
- Model type : sélectionnez LLM.
- Model name : pour un déploiement vLLM, envoyez une requête GET au point de terminaison /v1/models pour obtenir le nom. Pour cet exemple, saisissez Qwen3-8B.
- API key : saisissez votre jeton de service PAI-EAS.
- API endpoint URL : Saisissez le point de terminaison public de votre service PAI-EAS et ajoutez /v1 à la fin.
Tester l'intégration
1. Sur la page principale de Dify, cliquez sur Create Blank App, sélectionnez le type Chatflow, saisissez un nom d'application et d'autres informations, puis cliquez sur Create.
2. Cliquez sur le nœud LLM, sélectionnez le modèle que vous avez ajouté, et définissez le contexte et les invites. Sélectionnez Qwen3-8B CHAT dans la catégorie OpenAI-API-compatible. Dans l'invite SYSTEM, saisissez une description de rôle et référencez la variable de contexte sys.query. Dans la zone USER, ajoutez les variables sys.query et sys.files. Vous pouvez ajuster les paramètres du modèle tels que Max Tokens (la valeur par défaut est 512), Presence Penalty et Thinking Mode selon vos besoins.
3. Cliquez sur Preview dans le coin supérieur droit et saisissez une question.
  
  Le bot traite la question via le workflow et renvoie une réponse. Le haut de la zone de conversation affiche un état Deep thinking et le temps écoulé.

Chatbox

Accédez à Chatbox pour télécharger et installer le client pour votre appareil, ou cliquez sur Launch Web App pour la version web. Cet exemple utilise macOS M3.
Ajouter un fournisseur de modèle. Cliquez sur Settings, ajoutez un fournisseur de modèle, saisissez un nom tel que pai, et sélectionnez OpenAI API Compatible comme mode API.
Sélectionnez le fournisseur pai et configurez les paramètres suivants :
- API key : saisissez votre jeton de service PAI-EAS.
- API host : saisissez le point de terminaison public de votre service PAI-EAS et ajoutez /v1 à la fin.
- API path : laissez ce champ vide.
- Model : cliquez sur Get pour ajouter le modèle. Le moteur d'inférence BladeLLM ne prend pas en charge la récupération des modèles via l'API. Si vous utilisez BladeLLM, ajoutez le modèle manuellement en cliquant sur New.
Tester le chat. Cliquez sur New Chat et sélectionnez le service de modèle dans le coin inférieur droit de la zone de saisie de texte.

Le haut de l'interface de chat affiche l'invite système, telle que You are a helpful assistant.. Saisissez une question telle que « Who are you? » dans la zone de texte et envoyez-la. La zone de réponse de l'assistant affiche une section Deep thinking réduite avec le temps de réflexion, suivie de la réponse du modèle.

Cherry Studio

Installer le client

Visitez Cherry Studio pour télécharger et installer le client.

Vous pouvez également le télécharger depuis https://github.com/CherryHQ/cherry-studio/releases .
Configurer le service de modèle
1. Cliquez sur l'icône des paramètres dans le coin inférieur gauche. Sous la section Model Service, cliquez sur Add. Dans Provider name, saisissez un nom personnalisé, tel que PAI, et définissez le type de fournisseur sur OpenAI. Cliquez sur OK.
2. Dans le champ API key, saisissez votre jeton de service PAI-EAS. Dans le champ API address, saisissez le point de terminaison public de votre service PAI-EAS.
3. Cliquez sur Add et saisissez le nom du modèle dans le champ Model ID. Pour les déploiements vLLM, vous pouvez obtenir le nom en envoyant une requête GET à l'API /v1/models. Par exemple, saisissez Qwen3-8B. Le nom respecte la casse. Pour API Address, saisissez l'URL mais omettez le numéro de version v1 à la fin. Si l'URL se termine par un caractère #, le système force l'utilisation du chemin /v1/chat/completions. Une fois la configuration terminée, la section Model identifie et répertorie automatiquement les modèles disponibles, tels que Qwen3-8B.
4. Cliquez sur Test à côté du champ de saisie API key pour vérifier la connectivité.
Tester rapidement le modèle

Revenez à l'interface de chat, sélectionnez le modèle en haut et démarrez une conversation.

Par exemple, si vous saisissez Who are you? et que le modèle Qwen3-8B répond par une présentation de lui-même, cela indique que le modèle est déployé et fonctionne correctement.

Facturation

Les coûts incluent, sans s'y limiter, les éléments suivants. Pour plus d'informations, reportez-vous à la section Facturation de PAI-EAS.

Frais de calcul : il s'agit du coût principal. Lorsque vous créez un service PAI-EAS, choisissez des ressources en paiement à l'utilisation ou par abonnement en fonction de vos besoins.
Frais de stockage : si vous utilisez un modèle personnalisé, les fichiers du modèle sont stockés dans Object Storage Service (OSS), ce qui entraîne des frais de stockage.

Utilisation en production

Choisir le bon modèle

Définir votre scénario d'application :
- Conversation générale : choisissez toujours un modèle ajusté aux instructions, et non un modèle de base, afin de garantir que le modèle comprenne et suive vos instructions.
- Génération de code : choisissez des modèles spécialisés dans le code, tels que la série Qwen3-Coder, car ils offrent généralement de bien meilleures performances que les modèles polyvalents pour les tâches liées au code.
- Tâches spécifiques à un domaine : si votre tâche est hautement spécialisée, comme dans la finance ou le droit, envisagez de trouver un modèle qui a été affiné pour ce domaine, ou affinez vous-même un modèle polyvalent.
Équilibrer les performances et les coûts : les modèles plus grands sont généralement plus performants, mais nécessitent davantage de ressources informatiques et entraînent des coûts d'inférence plus élevés. Commencez par un modèle plus petit, tel qu'un modèle 7B, pour la validation. Si ses performances ne répondent pas à vos besoins, essayez un modèle plus grand.
Consulter les benchmarks faisant autorité : vous pouvez consulter des classements tels que OpenCompass et LMSys Chatbot Arena. Ces classements évaluent les modèles sur plusieurs dimensions, notamment le raisonnement, la programmation et les mathématiques, et peuvent fournir des indications précieuses pour la sélection des modèles.

Choisir le bon moteur d'inférence

vLLM/SGLang : en tant que choix principaux au sein de la communauté open source, ils offrent une large prise en charge des modèles ainsi qu'une documentation et des exemples communautaires étendus, ce qui facilite leur intégration et leur dépannage.
BladeLLM : un moteur d'inférence développé par l'équipe PAI d'Alibaba Cloud. Il est profondément optimisé pour des modèles spécifiques, en particulier la série Qwen, et peut offrir des performances plus élevées et une utilisation moindre de la mémoire GPU.

Optimisation de l'inférence

Déployer un LLM avec un routage intelligent : distribue dynamiquement les requêtes en fonction de métriques en temps réel telles que le débit de tokens et l'utilisation de la mémoire GPU. Cette approche équilibre la puissance de calcul et l'allocation de la mémoire entre les instances d'inférence et convient aux déploiements comportant plusieurs instances d'inférence et des charges de requêtes inégalement réparties. Cela améliore l'utilisation des ressources du cluster et la stabilité du système.
Déployer des modèles Mixture of Experts (MoE) en utilisant le parallélisme d'experts et la séparation PD : pour les modèles Mixture of Experts (MoE), cette approche utilise des techniques telles que le parallélisme d'experts (EP) et la séparation Prefill-Decode (PD) pour améliorer le débit d'inférence et réduire les coûts de déploiement.

FAQ

Q : Le service reste bloqué à l'état Pending

Suivez ces étapes pour résoudre le problème :

Vérifier l'état de l'instance : sur la page de liste des services, cliquez sur le nom du service pour accéder à la page de détails. Dans la section Service Instance, vérifiez l'état de l'instance. Si elle indique insufficient resources, le groupe de ressources public actuel ne dispose pas d'une capacité suffisante.
Solutions (par ordre de priorité) :
1. Option 1 : Modifier le type d'instance. Revenez à la page de déploiement et sélectionnez un autre modèle de GPU.
2. Solution 2 : Utiliser des ressources dédiées. Pour Resource Type, sélectionnez un groupe de ressources EAS afin d'utiliser des ressources dédiées (le groupe de ressources doit être créé au préalable).
Mesures préventives :
1. Créez un groupe de ressources dédié pour éviter les limitations des ressources publiques.
2. Pendant les heures de pointe, effectuez des tests dans plusieurs régions.

Q : Erreurs d'appel

L'appel API renvoie l'erreur suivante : Unsupported Media Type: Only 'application/json' is allowed

Assurez-vous que les en-têtes de requête contiennent Content-Type: application/json.
L'appel API renvoie l'erreur suivante : The model '<model_name>' does not exist.

Le moteur d'inférence vLLM nécessite que le champ model soit correctement spécifié. Vous pouvez obtenir le nom du modèle en appelant le point de terminaison /v1/models avec une requête GET.

Pour d'autres questions, reportez-vous à la section FAQ EAS.