Remarque
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Run :ai Model Streamer lit simultanément les tenseurs de modèle et les transmet vers la mémoire GPU, en superposant les lectures de stockage avec les transferts CPU à GPU. Cette capacité peut réduire le temps de chargement du modèle et réduire le temps d’inactivité du GPU lors du démarrage et de la montée en charge du serveur d’inférence. Utilisez-la pour charger les modèles SafeTensors depuis Stockage Blob Azure dans vLLM, car elle prend en charge le chargement direct depuis le stockage d’objets et s’intègre au chargeur de modèles de vLLM. Pour l’intégration upstream, voir Chargement des modèles avec Run :ai Model Streamer.
En utilisant un accélérateur distribué pour le stockage cloud (DACS), ce chemin de chargement peut également réutiliser les données de modèles mises en cache entre les charges de travail. vLLM utilise le backend Azure de Run :ai pour charger la bibliothèque cliente native DACS. Les opérations de lecture récupèrent les données mises en cache ou récupèrent les données absentes depuis Stockage Blob.
Cet article utilise Run :ai Model Streamer 0.17.3, le paquet public dacs-client==0.1.0 et la v0.1.0 version serveur. La procédure principale installe les dépendances dans votre image de charge de travail. Il ne nécessite pas d’image client DACS séparée ni de support Kubernetes ImageVolume.
Terminez l’article Prise en main de l’accélérateur distribué pour le stockage cloud sur AKS avant d’utiliser cet article. Pour fournir les bibliothèques clients DACS sans reconstruire votre image de charge de travail, voir Monter les bibliothèques clients DACS avec ImageVolume.
Prerequisites
- Un déploiement DACS existant et son nom d’hôte de service de découverte.
- Un pool de nœuds GPU AKS avec des pilotes NVIDIA compatibles, un plugin de périphérique, et suffisamment de mémoire GPU pour votre modèle. L’exemple suivant utilise
bfloat16, qui nécessite un GPU compatible. - Pour l’authentification par identité de charge de travail, un cluster AKS doit avoir l’émetteur OIDC et l’ID de charge de travail Microsoft Entra activés. Voir Activer l’émetteur OIDC et ID de charge de travail Microsoft Entra sur un cluster AKS.
- Une image GPU vLLM compatible et un environnement Linux avec glibc 2.35 ou plus récent. Utilise le même environnement Python que ton application.
- Un conteneur Blob privé pour les fichiers modèles.
- Un utilisateur ou une identité gérée séparée avec Storage Blob Data Contributor sur le conteneur du modèle.
- Une identité d’inférence avec Storage Blob Data Reader sur le conteneur du modèle. Configurez une méthode dans Configurer l’authentification Blob.
- Permission de construire et de pousser votre image de charge de travail, et permission pour AKS de l’extraire.
- Azure CLI, AzCopy v10, et la CLI Hugging Face sur votre machine de préparation si vous devez télécharger un modèle.
La préparation du modèle ne nécessite pas de GPU. Vous pouvez également vérifier l’installation des paquets, le chargement de la bibliothèque native et l’authentification Blob sur les nœuds CPU avec une image d’application compatible. Ces vérifications ne valident pas la planification GPU, la taille de la mémoire ou l’inférence.
Téléverser les fichiers de modèles vers Stockage Blob
Passez cette section si le modèle complet est déjà dans votre conteneur privé. Pour un test de cache à froid, utilisez un préfixe de modèle que vous n’avez pas consulté dans DACS.
Utilisez l’identité du téléverseur pour cette procédure, et non l’identité d’inférence. Pour les assignations de rôles à portée de conteneur, voir Assigner un rôle Azure pour accéder aux données de blob. Azure control-plane Owner ou Contributor seul n'accorde pas l'accès aux données Blob via Microsoft Entra ID.
Téléchargez le modèle
L’exemple suivant télécharge les fichiers d’inférence pour SmolLM2-135M-Instruct à une révision fixe. Sa carte de modèle identifie la licence comme Apache-2.0. Installez la Hugging Face CLI, puis exécutez :
MODEL_ID="HuggingFaceTB/SmolLM2-135M-Instruct"
MODEL_REVISION="12fd25f77366fa6b3b4b768ec3050bf629380bac"
MODEL_DIR="$PWD/models/SmolLM2-135M-Instruct-$MODEL_REVISION"
hf download "$MODEL_ID" \
config.json generation_config.json model.safetensors \
tokenizer.json tokenizer_config.json special_tokens_map.json \
vocab.json merges.txt README.md \
--revision "$MODEL_REVISION" \
--local-dir "$MODEL_DIR"
Facultativement, utilisez la commande hf cache verify d’une CLI actuelle pour vérifier les fichiers téléchargés par rapport aux sommes de contrôle du Hub :
hf cache verify "$MODEL_ID" \
--revision "$MODEL_REVISION" \
--local-dir "$MODEL_DIR"
Comme ce téléchargement ne sélectionne que des fichiers d’inférence, la vérification peut signaler l’absence de fichiers de dépôt tels que des variantes de modèles inutilisées. Il peut également rapporter des métadonnées supplémentaires de téléchargement local de Hugging Face. Ces messages ne sont pas des erreurs de somme de contrôle. Enquêtez sur les fichiers inattendus ou les incompatibilités de somme de contrôle avant de les téléverser.
Pour un autre modèle, incluez tous les fragments SafeTensors ainsi que tout index de poids, configuration de modèle et de génération, les fichiers tokenizer, ainsi que les fichiers de licence et d’attribution applicables. Conservez la structure de répertoire requise. N’ajoutez pas de variantes ONNX sans rapport, de points de contrôle d’entraînement, de fichiers optimiseurs ou d’identifiants.
Téléverser avec AzCopy
Installez AzCopy v10. Connectez-vous via Azure CLI en tant qu'utilisateur du téléchargeur, puis copiez le contenu du répertoire local dans un nouveau préfixe Blob :
TENANT_ID="<tenant-id>"
STORAGE_ACCOUNT="<storage-account>"
CONTAINER="<container>"
RUN_ID="$(date -u +%Y%m%dT%H%M%SZ)"
MODEL_PREFIX="models/SmolLM2-135M-Instruct-${MODEL_REVISION}-${RUN_ID}"
MODEL_URL="https://${STORAGE_ACCOUNT}.blob.core.windows.net/${CONTAINER}/${MODEL_PREFIX}"
az login --tenant "$TENANT_ID"
export AZCOPY_AUTO_LOGIN_TYPE=AZCLI
export AZCOPY_TENANT_ID="$TENANT_ID"
azcopy copy "$MODEL_DIR/*" "$MODEL_URL" \
--recursive=true \
--overwrite=false \
--exclude-path ".cache;.git"
azcopy list "$MODEL_URL"
Le caractère générique cité copie le contenu du répertoire directement dans le préfixe sans ajouter de niveau local. Les exclusions omettent les métadonnées de téléchargement et les métadonnées Git. Continuez seulement après qu’AzCopy ne signale aucun transfert échoué et que la destination contient tous les fichiers requis. Pour plus d’informations, consultez Télécharger le contenu du répertoire avec AzCopy et Autoriser AzCopy avec Azure CLI.
Pour un uploader fonctionnant sur une VM Azure, vous pouvez à la place autoriser AzCopy avec une identité managée. Gardez le conteneur privé et supprimez les affectations temporaires de rôles de téléchargeur après la préparation. Laisser le temps pour que les nouvelles assignations de rôles se propagent ; ne contournez pas les erreurs d’autorisation en ajoutant des clés de stockage ou des secrets clients.
Enregistrez la révision du modèle et les versions de Blob ou les ETags. L’emplacement du modèle Run :ai est az://<container>/<model-prefix>. Gardez ces fichiers inchangés entre les chargements à froid et à chaud. Pour un autre test à froid, utilisez un nouveau préfixe plutôt que d’expulser des données d’un cache partagé.
Préparez l’image de workload sans ImageVolume
Installez les dépendances pendant la construction de votre image, pas au démarrage du pod. Conservez votre application existante, votre image de base et votre point d’entrée. Utilisez le gestionnaire de paquets de l’application ainsi que le flux de travail des exigences ou contraintes pour préserver les dépendances compatibles, y compris Torch, CUDA et NumPy.
Utilisez une image vLLM compatible GPU avec des versions Torch et CUDA compatibles avec vos nœuds GPU et les pilotes NVIDIA. Vérifiez les packages Run:ai core et Azure installés dans l'image avant d'ajouter des dépendances ; toutes les images vLLM n'incluent pas le backend Azure.
Résolvez les conflits de dépendances dans votre image de charge de travail avant de déployer. L’étape pip check de la section suivante doit être accomplie avec succès. Utilisez les contraintes de dépendance de votre application pour préserver la compatibilité avec les autres paquets installés.
Si votre image ne contient pas déjà les packages compatibles Run :ai core et Azure backend, ajoutez l'instruction suivante à votre fichier Docker :
RUN python3 -m pip install --no-cache-dir "runai-model-streamer[azure]==0.17.3"Installez le paquet client DACS public, qui fournit les bibliothèques clientes natives, dans ce même environnement Python :
RUN python3 -m pip install --no-cache-dir "dacs-client==0.1.0" && \ python3 -m pip checkAzure extra de Run :ai n'installe pas les bibliothèques clients DACS. Si votre application dispose déjà de packages Run :ai compatibles, seule l’installation du paquet client DACS est nécessaire.
Construis et pousse en utilisant ton Dockerfile et le contexte de construction existant. Exécutez les commandes suivantes dans Bash sur votre machine de préparation. Cet exemple est construit pour des nœuds x86-64 :
REGISTRY_NAME="<registry-name>" REGISTRY_SERVER="$(az acr show --name "$REGISTRY_NAME" --query loginServer --output tsv)" WORKLOAD_IMAGE="$REGISTRY_SERVER/workload-runai-dacs:0.17.3-0.1.0" az acr login --name "$REGISTRY_NAME" docker build --platform linux/amd64 -t "$WORKLOAD_IMAGE" . docker push "$WORKLOAD_IMAGE"Dans la même session Bash, résoudre le chemin de la bibliothèque native à partir de l’image construite :
docker run --rm --entrypoint python3 "$WORKLOAD_IMAGE" \ -c 'from importlib.metadata import distribution; from pathlib import Path; p=Path(distribution("dacs-client").locate_file("py_dacs_client/libStorageDirect.so")).resolve(); assert p.is_file(), p; print(p)'Utilisez le chemin absolu imprimé lors de la configuration du workload. Conservez l’installation complète du client, y compris les bibliothèques natives associées.
Préférez un condensé immuable de l’image lors du déploiement. La mise à jour du client intégré nécessite de reconstruire et de redéployer l’image de la charge de travail.
Configurer l’authentification Blob
Utilisez l’identité de la charge de travail AKS pour l’authentification Blob. L’exemple de déploiement utilise cette méthode avec Storage Blob Data Reader limité au conteneur du modèle. La permission d’écriture du téléchargeur n’est pas nécessaire pour l’inférence. Pour d’autres méthodes d’authentification, voir authentification Azure dans la documentation Run :ai Model Streamer.
Utiliser l’identité de charge de travail AKS
L’exemple de déploiement utilise ServiceAccount runai-reader dans l’espace de noms runai-dacs. Suivez les étapes suivantes avant de déployer la charge de travail :
Activez l'émetteur OIDC et ID de charge de travail Microsoft Entra sur votre cluster AKS existant, s'ils ne sont pas déjà activés.
Créez une identité gérée, ou sélectionnez une identité existante.
Si l’espace
runai-dacsde noms n’existe pas déjà, créez-le.kubectl create namespace runai-dacsCréez un Kubernetes ServiceAccount annoté avec l’ID client de cette identité.
Créez les informations d’identification d’identité fédérée pour l’espace de noms exact et le ServiceAccount. Vous n'avez pas besoin de suivre les étapes suivantes du Key Vault.
Attribuez le rôle de lecteur Blob à l’identité gérée fédérée à votre application ServiceAccount. Pour un exemple d’attribution à portée de conteneur, voir Accorder l’accès en lecture aux données du modèle, en substituant cette identité à l’identité kubelet du démarrage rapide.
Le pod doit sélectionner le ServiceAccount et porter l’étiquette azure.workload.identity/use: "true". AKS injecte les paramètres d’identité et le jeton projeté. N’ajoutez pas manuellement les secrets clients ou les clés de compte de stockage.
Configurez séparément l’accès à l’image pull
Pour les images ACR privées, configurez les autorisations de pull de l’identité kubelet comme décrit dans Ajouter le client à une image de charge de travail. Utilisez AcrPull pour le RBAC classique. Pour un registre compatible ABAC, utilisez Container Registry Repository Reader avec un accès approprié au dépôt de données (repository). N'utilisez pas --attach-acr pour ce registre.
L’accès en lecture blob-read pour l’identité de l’application n’accorde pas au kubelet l’accès d’extraction d’image. Pour ImageVolume, l’accès pull doit couvrir à la fois le workload et les images client, y compris des registries ou dépôts séparés lorsque cela est applicable.
Configurez et déployez la charge de travail
Définissez ces quatre variables d’application avant de commencer vLLM. Ils sont distincts des paramètres d’identité fournis par votre méthode d’authentification :
| Variable d'environnement | Purpose |
|---|---|
AZURE_STORAGE_ACCOUNT_NAME |
Compte de stockage contenant le modèle. |
CACHE_DISCOVERY_URL |
Nom d’hôte de découverte DACS, comme cache-sample-discovery.<namespace>.svc.cluster.local. |
CACHE_SERVER_PORT |
Porte du cache, généralement 9065. |
RUNAI_STREAMER_EXPERIMENTAL_AZURE_CACHE_LIB |
Chemin absolu de bibliothèque native résolu à partir de votre image de charge de travail. |
Important
La découverte du cache n’est pas optionnelle. Un chargement de modèle peut réussir en lisant directement Stockage Blob lorsque le cache n'est pas configuré. Avec le backend 0.17.3Run :ai Azure, spécifiez également explicitement le chemin de la bibliothèque native au lieu de dépendre de la découverte automatique.
Utilisez le format URI modèle de Run :ai, az://<container>/<model-prefix>, avec le compte fourni via AZURE_STORAGE_ACCOUNT_NAME. Ce format URI diffère de l'URI canonique du client Python natif, qui inclut le nom d'hôte du compte.
Remplacez les placeholders dans l’exemple suivant et enregistrez-les sous runai-dacs-pod.yaml. Utilisez le préfixe modèle de votre upload et le chemin de la bibliothèque native imprimé par l’image construite. L’exemple utilise l’identité de la charge de travail et ne contient ni ImageVolume ni conteneur d’initialisation :
apiVersion: v1
kind: Pod
metadata:
name: runai-dacs-vllm
namespace: runai-dacs
labels:
azure.workload.identity/use: "true"
spec:
serviceAccountName: runai-reader
restartPolicy: Never
nodeSelector:
agentpool: "<gpu-nodepool-name>"
tolerations:
- key: nvidia.com/gpu
operator: Exists
effect: NoSchedule
containers:
- name: vllm
image: "<workload-image>"
command: ["vllm", "serve"]
args:
- "az://<container>/<model-prefix>"
- "--load-format"
- "runai_streamer"
- "--served-model-name"
- "cached-model"
- "--dtype"
- "bfloat16"
- "--max-model-len"
- "1024"
env:
- name: AZURE_STORAGE_ACCOUNT_NAME
value: "<storage-account>"
- name: CACHE_DISCOVERY_URL
value: "<cache-discovery-hostname>"
- name: CACHE_SERVER_PORT
value: "9065"
- name: RUNAI_STREAMER_EXPERIMENTAL_AZURE_CACHE_LIB
value: "<dacs-native-library-path>"
- name: RUNAI_STREAMER_CHUNK_BYTESIZE
value: "8388608"
- name: SI_streamingChunkSize
value: "8388608"
resources:
requests:
cpu: "4"
memory: 16Gi
limits:
cpu: "4"
memory: 16Gi
nvidia.com/gpu: 1
ports:
- containerPort: 8000
readinessProbe:
httpGet:
path: /health
port: 8000
periodSeconds: 10
timeoutSeconds: 5
volumeMounts:
- name: shm
mountPath: /dev/shm
volumes:
- name: shm
emptyDir:
medium: Memory
sizeLimit: 2Gi
Ces ressources illustrent un petit modèle, pas un modèle 30B. Préservez la planification, les ressources, les sondes, la mémoire partagée et les autres arguments vLLM requis pour votre charge de travail. Ajustez le nombre de GPU, le parallélisme tensoriel, la longueur du modèle et la taille de la mémoire pour votre modèle. Pour un déploiement ou un StatefulSet, appliquez les étiquettes Pod sous spec.template.metadata et Paramètres Pod sous spec.template.spec.
Le premier déploiement démarre le vLLM et charge le modèle avant que le Pod ne soit prêt. Pour une comparaison du cache-froid, suivez ces étapes dans l’ordre :
Sélectionnez les données de modèle que le cache n’a pas lues, comme le préfixe neuf de la procédure d’importation. Ne retirez pas les données d’un cache partagé.
Avant de déployer le Pod applicatif, capturez un instantané de métriques de référence à partir de chaque Pod serveur de cache, comme décrit dans Surveiller l'accélérateur distribué pour le stockage cloud. Notez l’horodatage et les
cache_server_upload_request_size_bytes_sum,cache_server_download_request_size_bytes_sumetcache_server_cache_size_bytesde chaque serveur.Déploiez et inspectez le Pod accepté :
kubectl apply --dry-run=server -f runai-dacs-pod.yaml kubectl apply -f runai-dacs-pod.yaml kubectl -n runai-dacs get pod runai-dacs-vllm -o yaml kubectl -n runai-dacs wait --for=condition=Ready pod/runai-dacs-vllm --timeout=30m
Vérifier le runtime de charge de travail
Effectuez cette vérification à l'intérieur du conteneur vLLM, en utilisant l'exécutable Python de l'application. Il vérifie la cohérence des paquets et le chargement des bibliothèques natives, pas l’authentification Blob ni l’utilisation du cache :
kubectl -n runai-dacs exec -i runai-dacs-vllm -c vllm -- python3 - <<'PY'
import ctypes
import os
import subprocess
import sys
from importlib.metadata import version
for package in (
"vllm",
"torch",
"runai-model-streamer",
"runai-model-streamer-azure",
):
print(f"{package}: {version(package)}", flush=True)
subprocess.run([sys.executable, "-m", "pip", "check"], check=True)
path = os.environ["RUNAI_STREAMER_EXPERIMENTAL_AZURE_CACHE_LIB"]
print(f"Checking DACS native library: {path}", flush=True)
library = ctypes.CDLL(path)
print(f"DACS native library loaded: {path}")
PY
Résolvez les erreurs avant de continuer. Pour le déploiement du GPU, vérifiez également la visibilité du GPU et les logs moteur de vLLM pour confirmer l’exécution CUDA et le type de données prévu du modèle. La préparation ou un chargement réussi de la bibliothèque ne prouvent pas à eux seuls l’exécution du GPU ou l’utilisation du cache DACS.
Vérifier le comportement du cache à froid et à chaud
Utilisez la base de référence des métriques de pré-déploiement collectées dans Configuration et déploiement de la charge de travail. Le chargement du modèle effectué lors du déploiement est le chargement à froid.
Vérifier la charge à froid
Inspectez le journal de l’application :
kubectl -n runai-dacs logs runai-dacs-vllm -c vllm
Recherchez des applications natives ReadChunk stats.
RemoteClient compte les lectures pondérées de la mémoire de sauvegarde ; RemoteCache compte les lectures du cache distant. Certains accès au cache lors du premier chargement sont normaux, car les lectures antérieures peuvent alimenter le cache.
GetProperties Les hits du cache décrivent les métadonnées, pas les hits sur les poids du modèle.
Envoyez une demande d’inférence :
kubectl -n runai-dacs exec -i runai-dacs-vllm -c vllm -- python3 - <<'PY'
import json
import urllib.request
body = json.dumps({
"model": "cached-model",
"prompt": "Once upon a time",
"max_tokens": 16,
"temperature": 0,
}).encode()
request = urllib.request.Request(
"http://127.0.0.1:8000/v1/completions", data=body,
headers={"Content-Type": "application/json"},
)
with urllib.request.urlopen(request, timeout=600) as response:
result = json.load(response)
print(json.dumps(result, indent=2))
assert result["choices"][0]["text"].strip()
assert result["usage"]["completion_tokens"] > 0
PY
Confirmez les lectures non nulles du stockage de support à froid. Gardez le Pod de l’application en marche pendant que vous vérifiez la population du cache asynchrone :
- Échantillonner
cache_server_upload_request_size_bytes_sumetcache_server_cache_size_bytesà partir de chaque Pod de serveur de cache pour la ressource de cache sélectionnée toutes les 10 secondes, pendant jusqu’à cinq minutes. Utilisez la procédure du point de terminaison metrics. Utilisez de nouveaux échantillons, pas des copies répétées d’une extraction stockée. - Comparez les échantillons avec la référence de prédéploiement. Exiger une augmentation du nombre total d’octets téléversés et d’octets en cache sur ces serveurs. N'exigez pas que chaque serveur reçoive des données.
- Attendez que le compteur d'octets envoyés de chaque serveur reste inchangé pendant trois intervalles d'échantillonnage consécutifs après l'augmentation totale du volume de données envoyées. Confirmez qu’aucun serveur n’a redémarré et qu’aucun compteur n’a été réinitialisé pendant la comparaison.
- Enregistrez cet échantillon final comme instantané après démarrage à froid, y compris
cache_server_download_request_size_bytes_sumde chaque serveur comme référence pour la charge chaude.
Si ces conditions ne sont pas remplies dans les cinq minutes, arrêtez la comparaison plutôt que de considérer le cache comme initialisé. Vérifiez les erreurs d’envoi du client, l’état du serveur de cache et le trafic en cours avant de réessayer. Les modèles plus grands peuvent nécessiter une fenêtre d’observation plus longue. Un indicateur manquant ou une collecte échouée n’est pas une valeur nulle ni une preuve que les téléchargements sont terminés.
Les compteurs stables sont un signal de préparation, pas une preuve que chaque bloc de modèle est mis en cache. Le trafic de cache partagé peut également empêcher la stabilisation ou expliquer des hausses. Utilisez une fenêtre de validation discrète lorsque possible, et exigez les vérifications de lectures sur cache chaud du Pod frais ci-dessous pour confirmer la réutilisation du cache distribué.
Vérifiez un chargement à chaud dans un nouveau pod
Enregistrez le cold log et l’UID du pod. Recréez uniquement le pod d’application en utilisant les mêmes fichiers modèles, le même point de terminaison cache, la même bibliothèque et la même taille de bloc :
kubectl -n runai-dacs logs runai-dacs-vllm -c vllm > runai-cold.log
kubectl -n runai-dacs get pod runai-dacs-vllm -o jsonpath='{.metadata.uid}' > runai-cold.uid
kubectl -n runai-dacs delete pod runai-dacs-vllm --wait=true
kubectl apply -f runai-dacs-pod.yaml
kubectl -n runai-dacs wait --for=condition=Ready pod/runai-dacs-vllm --timeout=30m
kubectl -n runai-dacs get pod runai-dacs-vllm -o jsonpath='{.metadata.uid}' > runai-warm.uid
kubectl -n runai-dacs logs runai-dacs-vllm -c vllm > runai-warm.log
Répétez la vérification à l’exécution et la demande d’inférence. Ensuite, capturez un instantané des métriques après préchauffage depuis chaque serveur de cache. Confirmez les différents UID de pod, l’augmentation du taux de réussite du cache de source distante et la diminution du nombre de lectures du stockage de support. Comparez cache_server_download_request_size_bytes_sum avec l’instantané après démarrage à froid pour confirmer les lectures du cache à chaud. Un nouveau processus évite de confondre un préchargement local en mémoire avec un accès réussi dans le cache distribué.
Le taux de réussite de la source distante est RemoteCache / (RemoteCache + RemoteClient), hors prérécupération locale. Utilisez le dernier instantané cumulatif pour chaque processus natif, point de montage et taille de bloc ; ne sommez pas les échantillons périodiques. Excluez les mesures affectées par les redémarrages du serveur cache ou les réinitialisations de compteurs. Les compteurs de serveurs partagés corroborent les journaux d’application mais n’attribuent pas tout le trafic à une seule charge de travail.
Les métadonnées peuvent toujours accéder à Stockage Blob même lorsque les compteurs warm weight-read affichent zéro lecture du stockage sous-jacent.
Montez les bibliothèques clients DACS avec ImageVolume
Utilisez cette alternative uniquement lorsque le nœud prend en charge ImageVolume et que vous avez une image client extractible construite à partir du wheel DACS public. Ne partez pas du principe qu’une image ou un tag MCR proposé soit publié. Si aucune image client appropriée n’est disponible, utilisez la procédure workload-image de la section précédente.
Votre image vLLM GPU doit déjà contenir des packages compatibles Run :ai core et Azure. Vous n'avez pas besoin d'installer le paquet client DACS dans son environnement Python car le volume de l'image fournit les bibliothèques clientes natives.
Adaptez l’exemple du pod comme suit :
Conservez votre image vLLM compatible existante au lieu de la reconstruire pour installer les bibliothèques clients DACS.
Ajoutez un volume d’image client en lecture seule et montez :
# Add to spec.volumes. - name: dacs-client image: reference: "<accessible-client-image>" pullPolicy: IfNotPresent # Add to the vLLM container's volumeMounts. - name: dacs-client mountPath: /opt/cache-client readOnly: trueDéfinissez
RUNAI_STREAMER_EXPERIMENTAL_AZURE_CACHE_LIBsur le chemin absolu delibStorageDirect.sosous/opt/cache-client, selon la disposition réelle de cette image. Préserver les dépendances natives homologues.Déployez et vérifiez que le volume de l’image et la monture en lecture seule restent dans la spécification du pod live. Vérifiez que le fichier existe, puis exécutez le même runtime de conteneur d’application et les mêmes vérifications à froid/à chaud.
Certains clusters plus anciens peuvent supprimer des champs et montages de volume d’image non pris en charge du pod admis. La version Kubernetes et la vérification à blanc du serveur ne suffisent pas à elles seules. N’installez pas et ne préchargez pas une version conflictuelle des bibliothèques clients DACS en même temps que le client monté ; un chemin de bibliothèque absolu n’isole pas son espace de noms natif de dépendances.
Optimiser les performances en lecture
Pourquoi ajuster la taille des blocs ? Les modèles ont des tailles de tenseur et des motifs de lecture différents, donc une taille de bloc peut ne pas offrir les meilleures performances de chargement pour chaque modèle. Les chunks surdimensionnés récupèrent plus de données que nécessaire pour une lecture et augmentent la mise en mémoire tampon. Des blocs sous-dimensionnés augmentent le nombre de requêtes et la surcharge par requête. Choisir une taille adaptée aux tenseurs courants du modèle équilibre ces coûts, améliore le débit efficace de lecture de poids et réduit le temps de chargement du modèle, y compris les chargements à chaud provenant des DACS. Considérez les recommandations suivantes comme points de départ et mesurez séparément les temps de chargement au froid et au chaud. Les gains dépendent du modèle, du parallélisme du chargeur, ainsi que des performances de stockage et de réseau.
Choisissez la taille d’un morceau en suivant les recommandations spécifiques au modèle suivantes. Pour d’autres modèles, inspectez les métadonnées tensorielles comme décrit dans la section suivante, ou utilisez 32 MiB si l’inspection des métadonnées n’est pas disponible.
| Model | Taille de bloc recommandée | Valeur en octets |
|---|---|---|
qwen3-coder-30b-a3b-instruct |
3 MiB | 3145728 |
gpt-oss-20b |
2 Mio | 2097152 |
deepseek-r1-0528 |
14 MiB | 14680064 |
deepseek-v3-0324 |
14 MiB | 14680064 |
phi-2 |
2 Mio | 2097152 |
mistral-small-4-119b-2603-nvfp4 |
2 Mio | 2097152 |
ministral-3-3b-instruct-2512 |
2 Mio | 2097152 |
ministral-3-3b-instruct (alias) |
2 Mio | 2097152 |
ministral-3-8b-instruct-2512 |
2 Mio | 2097152 |
ministral-3-8b-instruct (alias) |
2 Mio | 2097152 |
ministral-3-14b-instruct-2512 |
2 Mio | 2097152 |
ministral-3-14b-instruct (alias) |
2 Mio | 2097152 |
| Solution de secours lorsque l’inspection des métadonnées n’est pas disponible | 32 MiB | 33554432 |
Choisissez une taille de bloc pour un autre modèle
Utilisez un visualiseur de métadonnées Safetensors ou un outil d’inspection des en-têtes pour inspecter tous les fragments de modèles, sans charger le contenu des tenseurs :
- Trouvez la taille occupée en mémoire de chaque tenseur en octets : son offset de données de fin moins son décalage de départ. Excluez l’entrée
__metadata__. - Considérez chaque taille supérieure à 32 Mio comme 32 Mio avant de compter les occurrences.
- Sélectionnez la taille la plus fréquente sur tous les shards. Si plusieurs tailles apparaissent aussi souvent les unes que les autres, choisissez la plus grande.
- Si la taille sélectionnée est inférieure à 2 Mio, utilisez 2 MiB.
Par exemple, si les tenseurs de 3 MiB apparaissent le plus fréquemment après le capping, utilisez 3 MiB (3145728 octets). Si l’inspection des métadonnées n’est pas disponible, utilisez 32 MiB (33554432 octets).
Configurer l’application
Définir à la fois RUNAI_STREAMER_CHUNK_BYTESIZE et SI_streamingChunkSize à la valeur d’octet résultante dans l’environnement du conteneur applicatif. Par exemple, pour une recommandation de 3 MiB :
env:
- name: RUNAI_STREAMER_CHUNK_BYTESIZE
value: "3145728"
- name: SI_streamingChunkSize
value: "3145728"
Définissez ces valeurs explicitement ; le tableau décrit les recommandations, pas la détection automatique des modèles ni les paramètres par défaut intégrés. Recréez le Pod d’application après l’avoir modifié ; les serveurs de cache n’ont pas besoin d’être redémarrés. Les lecteurs et les tâches de remplissage partageant des données en cache doivent utiliser la même taille de bloc.
La taille de lecture de Run:ai et la taille native du bloc de cache sont des contrôles distincts, configurés ensemble ci-dessus. Évaluez la recommandation avec votre charge de travail, et ajustez la concurrence du chargeur séparément. Comparez les charges froides et chaudes indépendamment. Changer la taille du bloc de cache crée des clés de cache différentes et peut augmenter temporairement l’occupation du cache. Changez un réglage à la fois et mesurez le temps de chargement, les compteurs natifs, les métriques de cache, le CPU, le GPU et la mémoire hôte, ainsi que l’utilisation du réseau. L’alignement des tenseurs seul ne garantit pas de meilleures performances.
Warning
Le budget par défaut du tampon de téléversement asynchrone du client natif public est de 400 GiB dans 0.1.0. Ce n’est pas une préallocation ni une limite sûre de mémoire de Pod. Le préremplissage à froid de grands modèles peut épuiser un Pod plus petit. Pour les charges de travail limitées en mémoire, testez la population synchrone (SI_cacheEnableSyncUpload=true) ou un budget d’upload asynchrone borné (SI_cacheMaxUploadBufferSizePerProcessGB). Préparation du modèle de budget, tampons natifs de téléversement/préchargement, mémoire GPU, et /dev/shm séparément. Ces mesures de sécurité sont des paramètres optionnels spécifiques à la charge de travail, et non des exigences supplémentaires pour l’exemple du petit modèle.
Troubleshoot
| Symptôme | Cocher |
|---|---|
| Échec de l’extraction de l’image | Les autorisations d’extraction du kubelet, le mode d’autorisation du registre, le condensé de l’image et l’accès au réseau. |
| La bibliothèque native ne se charge pas | Environnement Python applicatif, chemin explicite, compatibilité glibc et bibliothèques sœurs natives. |
| Échec de l’autorisation du blob | Identité sélectionnée, rôle Lecteur, propagation du rôle, fédération et libellé du pod. Pour d’autres méthodes d’authentification, suivez les directives officielles d’authentification Azure mentionnées plus haut. |
| Le modèle se charge sans trafic de cache | Inclut les paramètres de découverte, le chargement du fournisseur, l’accessibilité DNS/réseau et les compteurs natifs de lecture de données. |
| Les warm loads lisent toujours les données Blob | Complétion de la population, versions de Blob, tailles de chunks correspondantes, expulsions et lectures partielles. |
| ImageVolume est manquant | Champs Live Pod et support nœud/runtime ; utilisez la méthode intégrée si cette méthode n’est pas disponible. |
| Le pod a été arrêté par manque de mémoire (OOM) | Mémoire de modélisation et de préproduction, tampons natifs, dimensionnement du cache GPU/KV, et /dev/shm. |
Pour une comparaison directe distincte du Blob, configurez RUNAI_STREAMER_EXPERIMENTAL_AZURE_CACHE_ENABLED=0 et recréez un Pod de test. Le régler sur 1 à la place fait que les échecs de chargement du fournisseur font échouer le démarrage plutôt que de basculer silencieusement sur une solution de repli. Aucun des deux paramètres ne prouve qu’il y a des accès réussis au cache ; inspectez les compteurs de lectures de données.
Nettoyer l’exemple
Si vous avez créé le Pod d’exemple autonome, supprimez-le une fois terminé :
kubectl -n runai-dacs delete pod runai-dacs-vllm --wait=true
Supprimez uniquement les préfixes du modèle, images, identités, fédérations, espaces de noms et attributions de rôles que vous avez créés pour cet exemple et dont vous n’avez plus besoin. Ne supprimez pas un cache partagé existant ou une identité partagée existante. Les données du modèle conservées sont maintenant chaudes ; utilisez un préfixe neuf pour une autre validation du cache à froid.