Tous les produits
Search
Centre de documentation

Container Service for Kubernetes:Quickly deploy a large language model inference service in ACK

Dernière mise à jour :Aug 11, 2026

Les clusters managés Pro ACK offrent un environnement prêt à l'emploi pour exécuter des services d'inférence de grands modèles de langage (LLM), sans matériel GPU local ni configuration complexe des dépendances. Ce guide présente deux méthodes de déploiement : une option rapide pour valider un modèle en environ 15 minutes, et une option adaptée à la production qui précharge les fichiers du modèle sur un stockage persistant afin de réduire les temps de démarrage à froid et les coûts de bande passante.

Prérequis

Avant de commencer, vérifiez que vous disposez des éléments suivants :

  • Un cluster managé Pro ACK exécutant Kubernetes 1.22 ou une version ultérieure

  • Au moins un nœud accéléré par GPU disposant de 16 Go de mémoire GPU ou plus

  • Le pilote NVIDIA version 535 ou ultérieure installé sur le pool de nœuds GPU (ce guide utilise 550.144.03, défini via l'étiquette ack.aliyun.com/nvidia-driver-version)

  • Le client Arena installé

Choisir une méthode de déploiement

Option 1 : Test rapide Option 2 : Production
Temps de configuration ~15 minutes Plus long (préchargement du modèle requis)
Stockage du modèle Téléchargé dans le conteneur au démarrage Préchargé sur Object Storage Service (OSS)
Démarrage à froid Lent — le modèle est retéléchargé à chaque redémarrage de pod Rapide — le modèle est déjà présent sur le volume monté
Idéal pour Valider les capacités d'inférence Charges de travail stables et répétitives en production

Option 1 : Déploiement rapide pour les tests

Utilisez Arena pour déployer qwen/Qwen1.5-4B-Chat depuis ModelScope. Le conteneur télécharge le modèle au démarrage ; le nœud GPU doit donc disposer d'au moins 30 Go d'espace disque libre.

  1. Exécutez la commande Arena pour déployer le service d'inférence :

    arena serve custom \
        --name=modelscope \
        --version=v1 \
        --gpus=1 \
        --replicas=1 \
        --restful-port=8000 \
        --readiness-probe-action="tcpSocket" \
        --readiness-probe-action-option="port: 8000" \
        --readiness-probe-option="initialDelaySeconds: 30" \
        --readiness-probe-option="periodSeconds: 30" \
        --image=kube-ai-registry.cn-shanghai.cr.aliyuncs.com/kube-ai/quick-deploy-llm:v1 \
        "MODEL_ID=qwen/Qwen1.5-4B-Chat python3 server.py"
    Pour extraire les fichiers de modèle depuis un dépôt Hugging Face, consultez la section Extraire les modèles depuis Hugging Face .

    La sortie suivante confirme la création des ressources Kubernetes pour modelscope-v1 :

    service/modelscope-v1 created
    deployment.apps/modelscope-v1-custom-serving created
    INFO[0002] The Job modelscope has been submitted successfully
    INFO[0002] You can run `arena serve get modelscope --type custom-serving -n default` to check the job status
  2. Vérifiez l'état du service. Le pod reste en état ContainerCreating pendant le téléchargement du modèle. Selon les conditions réseau, cette opération peut prendre de 5 à 15 minutes :

    arena serve get modelscope

    Lorsque l'état du pod passe à Running, le service d'inférence est prêt.

Option 2 : Déploiement prêt pour la production avec stockage persistant

Le préchargement des fichiers du modèle sur OSS évite de retélécharger des fichiers dépassant 10 Go à chaque redémarrage de pod. Cette approche réduit les temps de démarrage à froid, diminue les coûts de bande passante et améliore la stabilité du service.

Étape 1 : Télécharger les fichiers du modèle

  1. Installez Git et Git Large File Storage (LFS). macOS

    brew install git
    brew install git-lfs

    Windows Téléchargez et installez Git depuis le site officiel de Git. Git Large File Storage est inclus avec Git for Windows ; téléchargez la dernière version. Linux (basé sur Red Hat)

    yum install git
    yum install git-lfs

    Pour les autres distributions Linux, consultez le site officiel de Git.

  2. Clonez le dépôt du modèle Qwen1.5-4B-Chat et récupérez les fichiers volumineux :

    GIT_LFS_SKIP_SMUDGE=1 git clone https://www.modelscope.cn/qwen/Qwen1.5-4B-Chat.git
    cd Qwen1.5-4B-Chat
    git lfs pull

Étape 2 : Charger les fichiers du modèle sur OSS

  1. Installez et configurez ossutil.

  2. Créez un bucket. Pour réduire la latence de récupération du modèle, créez le bucket dans la même région que votre cluster :

    ossutil mb oss://<your-bucket-name>
  3. Créez un dossier dans le bucket pour les fichiers du modèle :

    ossutil mkdir oss://<your-bucket-name>/Qwen1.5-4B-Chat
  4. Chargez les fichiers du modèle :

    ossutil cp -r ./Qwen1.5-4B-Chat oss://<your-bucket-name>/Qwen1.5-4B-Chat

Étape 3 : Configurer un volume persistant (PV)

  1. Connectez-vous à la console ACK et cliquez sur le cluster cible. Dans le volet de navigation de gauche, sélectionnez Volumes > Persistent Volumes.

  2. Cliquez sur Create. Dans la boîte de dialogue Create PV, définissez les paramètres suivants et cliquez sur Create :

    Paramètre Valeur
    PV type OSS
    Volume name llm-model
    Capacity 20Gi
    Access mode ReadOnlyMany
    Access certificate Sélectionnez Create Secret
    Optional parameters -o umask=022 -o max_stat_cache_size=0 -o allow_other
    Bucket ID Cliquez sur Select Bucket et sélectionnez votre bucket
    OSS path /Qwen1.5-4B-Chat
    Endpoint Sélectionnez Public Endpoint

Étape 4 : Configurer une revendication de volume persistant (PVC)

  1. Dans le volet de navigation de gauche, sélectionnez Volumes > Persistent Volume Claims.

  2. Sur la page Persistent Volume Claims, définissez les paramètres suivants et cliquez sur Create :

    Paramètre Valeur
    PVC type OSS
    Name llm-model
    Allocation mode Sélectionnez Existing Volumes
    Existing volumes Sélectionnez le PV llm-model créé à l'étape précédente
    Capacity 20Gi

Étape 5 : Déployer le service d'inférence

Exécutez la commande Arena pour déployer le service. L'option --data monte le PVC contenant les fichiers du modèle préchargés. Comme le modèle est déjà présent sur le volume monté, le pod démarre sans aucun téléchargement :

arena serve custom \
    --name=modelscope \
    --version=v1 \
    --gpus=1 \
    --replicas=1 \
    --restful-port=8000 \
    --readiness-probe-action="tcpSocket" \
    --readiness-probe-action-option="port: 8000" \
    --readiness-probe-option="initialDelaySeconds: 30" \
    --readiness-probe-option="periodSeconds: 30" \
    --data=llm-model:/Qwen1.5-4B-Chat \
    --image=kube-ai-registry.cn-shanghai.cr.aliyuncs.com/kube-ai/quick-deploy-llm:v1 \
    "MODEL_ID=/Qwen1.5-4B-Chat python3 server.py"

La sortie suivante confirme la soumission du service d'inférence :

service/modelscope-v1 created
deployment.apps/modelscope-v1-custom-serving created
INFO[0001] The Job modelscope has been submitted successfully
INFO[0001] You can run `arena serve get modelscope --type custom-serving -n default` to check the job status

Vérifiez l'état du service :

arena serve get modelscope

Lorsque l'état du pod passe à Running, le service d'inférence est prêt.

Valider le service d'inférence

  1. Configurez la redirection de port vers le service d'inférence :

    Important

    kubectl port-forward est réservé au développement et au débogage. Cette méthode n'est ni fiable, ni sécurisée, ni évolutive en production. Pour la mise en réseau en production, consultez la section Gestion Ingress.

    kubectl port-forward svc/modelscope-v1 8000:8000

    Sortie attendue :

    Forwarding from 127.0.0.1:8000 -> 8000
    Forwarding from [::1]:8000 -> 8000
  2. Dans un nouveau terminal, envoyez une requête d'inférence de test :

    curl -X POST http://localhost:8000/generate \
      -H "Content-Type: application/json" \
      -d '{
        "text_input": "What is artificial intelligence? Artificial intelligence is",
        "parameters": {
          "stream": false,
          "temperature": 0.9,
          "seed": 10
        }
      }'

    Une réponse réussie contient le texte généré par le modèle :

    {"model_name":"/Qwen1.5-4B-Chat","text_output":"What is artificial intelligence? Artificial intelligence is a branch of computer science that studies how to make computers have intelligent behavior."}

(Facultatif) Nettoyer les ressources

Supprimez le service d'inférence et les ressources de stockage lorsque vous avez terminé :

# Delete the inference service
arena serve del modelscope

# Delete the PVC and PV (Option 2 only)
kubectl delete pvc llm-model
kubectl delete pv llm-model

FAQ

Comment extraire les fichiers de modèle depuis Hugging Face plutôt que depuis ModelScope ?

Assurez-vous que le runtime du conteneur peut atteindre le dépôt Hugging Face, puis définissez MODEL_SOURCE=Huggingface dans la commande Arena. Le nœud GPU nécessite au moins 30 Go d'espace disque libre pour accueillir les fichiers téléchargés :

arena serve custom \
    --name=huggingface \
    --version=v1 \
    --gpus=1 \
    --replicas=1 \
    --restful-port=8000 \
    --readiness-probe-action="tcpSocket" \
    --readiness-probe-action-option="port: 8000" \
    --readiness-probe-option="initialDelaySeconds: 30" \
    --readiness-probe-option="periodSeconds: 30" \
    --image=kube-ai-registry.cn-shanghai.cr.aliyuncs.com/kube-ai/quick-deploy-llm:v1 \
    "MODEL_ID=Qwen/Qwen1.5-4B-Chat MODEL_SOURCE=Huggingface python3 server.py"

La sortie suivante confirme la création des ressources :

service/huggingface-v1 created
deployment.apps/huggingface-v1-custom-serving created
INFO[0003] The Job huggingface has been submitted successfully
INFO[0003] You can run `arena serve get huggingface --type custom-serving -n default` to check the job status

Annexe : référence des paramètres de commande

Paramètre Description Exemple
serve custom Sous-commande Arena. Déploie un service de modèle personnalisé plutôt qu'un type prédéfini tel que tfserving ou triton.
--name Nom du service. Identifiant unique utilisé pour les opérations ultérieures, telles que la consultation des journaux ou la suppression du service. modelscope
--version Version du service. Étiquette de version du service, utile pour la gestion des versions et les déploiements progressifs. v1
--gpus Nombre de GPU. Nombre de GPU alloués à chaque pod. Requis lorsque le modèle nécessite des GPU pour l'inférence. 1
--replicas Nombre de réplicas. Nombre de pods à exécuter. Un plus grand nombre de réplicas augmente le débit simultané et la disponibilité. 1
--restful-port Port API RESTful. Port sur lequel le service expose son API RESTful pour recevoir les requêtes d'inférence. 8000
--readiness-probe-action Type de sonde de readiness. Méthode de vérification utilisée par la sonde de readiness Kubernetes pour déterminer si le conteneur est prêt à recevoir du trafic. tcpSocket
--readiness-probe-action-option Options du type de sonde. Paramètres pour le type de sonde choisi. Pour tcpSocket, spécifie le port à vérifier. port: 8000
--readiness-probe-option Paramètres supplémentaires de la sonde. Paramètres additionnels pour la sonde de readiness. Cet indicateur peut être répété. Définit le délai initial et l'intervalle de vérification. initialDelaySeconds: 30, periodSeconds: 30
--data Montage de volume. Monte un PVC à un chemin spécifié dans le conteneur, au format <pvc-name>:<mount-path>. Utilisé pour monter des fichiers de modèle préchargés. llm-model:/Qwen1.5-4B-Chat
--image Image de conteneur. URL complète de l'image de conteneur qui définit l'environnement d'exécution du service. kube-ai-registry.cn-shanghai.cr.aliyuncs.com/kube-ai/quick-deploy-llm:v1
[COMMAND] Commande de démarrage. Commande à exécuter après le démarrage du conteneur. Définit la variable d'environnement MODEL_ID et lance server.py. "MODEL_ID=/Qwen1.5-4B-Chat python3 server.py"

FAQ

Extraire les modèles depuis Hugging Face

  1. Assurez-vous que l'environnement d'exécution du conteneur peut accéder au dépôt Hugging Face.

  2. Utilisez le client Arena pour déployer un service personnalisé et spécifiez l'image de conteneur pour le déploiement à l'aide du paramètre --image. Pour plus d'informations sur les paramètres, consultez la section Référence des paramètres de commande.

    Cette méthode télécharge les fichiers de modèle Hugging Face dans le conteneur. Assurez-vous que votre nœud GPU dispose d'au moins 30 Go d'espace disque disponible.
    arena serve custom \
        --name=huggingface \
        --version=v1 \
        --gpus=1 \
        --replicas=1 \
        --restful-port=8000 \
        --readiness-probe-action="tcpSocket" \
        --readiness-probe-action-option="port: 8000" \
        --readiness-probe-option="initialDelaySeconds: 30" \
        --readiness-probe-option="periodSeconds: 30" \
        --image=kube-ai-registry.cn-shanghai.cr.aliyuncs.com/kube-ai/quick-deploy-llm:v1 \
        "MODEL_ID=Qwen/Qwen1.5-4B-Chat MODEL_SOURCE=Huggingface python3 server.py"

    La sortie suivante indique la création des ressources Kubernetes pour le service d'inférence huggingface-v1 :

    service/huggingface-v1 created
    deployment.apps/huggingface-v1-custom-serving created
    INFO[0003] The Job huggingface has been submitted successfully 
    INFO[0003] You can run `arena serve get huggingface --type custom-serving -n default` to check the job status 

Étapes suivantes