Guide de l'utilisateur pour les modèles Mistral avec vLLM sur GDC sous air gap

Ce document fournit des instructions détaillées pour déployer des modèles de pondération ouverts de Mistral AI sur des environnements Google Distributed Cloud (GDC) air-gapped. Il explique comment utiliser vLLM pour la diffusion à haut débit, en utilisant les fonctionnalités de la plate-forme GDC, y compris les ressources Kubernetes, Harbor et GPU. Sélectionnez le modèle et l'option de GPU dans la section "Modèle". Toutes les autres étapes sont identiques pour tous les modèles.

Modèles compatibles

Modèle	Dépôt Hugging Face	Paramètres	Licence	Options de GPU
Mistral 7B Instruct	mistralai/Mistral-7B-Instruct-v0.2	7,2 milliards (dense)	Apache 2.0	1 GPU (n'importe lequel)
Mistral NeMo 12B Instruct	mistralai/Mistral-Nemo-Instruct-2407	12B (dense)	Apache 2.0	1 GPU (n'importe lequel)
Mistral Small 3.2 24B Instruct	mistralai/Mistral-Small-3.2-24B-Instruct-2506	24B (dense, avec encodeur visuel)	Apache 2.0	1 NVIDIA A100 80 Go 1 NVIDIA H100 94 Go 1 NVIDIA H200 141 Go ou B300 288 Go
Ministral 8B Instruct	mistralai/Ministral-8B-Instruct-2410	8B (dense)	Licence de recherche Mistral AI (utilisation à des fins de recherche et non commerciale uniquement)	1 GPU (n'importe lequel)
Mixtral 8x7B Instruct	mistralai/Mixtral-8x7B-Instruct-v0.1	46,7 milliards au total / 12,9 milliards actifs (Mixture of Experts, 8x7B)	Apache 2.0	2 NVIDIA A100 80 Go 2 NVIDIA H100 94 Go 1 NVIDIA A100 80 Go ou H100 94 Go avec --quantization=fp8 1 NVIDIA H200 141 Go ou B300 288 Go
Magistral Small 1.2 24B	mistralai/Magistral-Small-2509	24B (dense, raisonnement, avec encodeur visuel)	Apache 2.0	1 NVIDIA A100 80 Go 1 NVIDIA H100 94 Go 1 NVIDIA H200 141 Go ou B300 288 Go

Remarque : Pour les dépôts Hugging Face protégés, vous devez accepter les conditions de licence sur la page du dépôt Hugging Face du modèle avec le compte dont le jeton d'accès est configuré dans ${HOME}/gdcag-solutions/open-weight-models/vllm/secrets/huggingface_token avant de télécharger les pondérations.

Architecture

La solution consiste à déployer un backend de diffusion conteneurisé (vLLM) en tant que déploiement dans un cluster standard. Les pondérations du modèle sont stockées sur des volumes persistants, renseignés à partir de fichiers téléchargés localement et importés à l'aide d'un pod de chargement. Un Service Kubernetes de type LoadBalancer expose l'API backend, et les objets NetworkPolicy / ProjectNetworkPolicy sécurisent l'accès à celle-ci.

Remarque : Sans StorageClass ReadOnlyMany, cette solution ne peut déployer qu'une seule instance répliquée.

Avant de commencer

Remarque : Ce guide nécessite GDC sous air gap 1.16.2-hf1 (1.16.2-gdch.1353-1) ou une version ultérieure, ainsi qu'un cluster standard.

Suivez l'implémentation de référence des modèles Open Weights avec vLLM sur le poste de travail et assurez-vous d'avoir accès au répertoire ${HOME}/gdcag-solutions.

Identity and Access Management

Assurez-vous que les comptes, rôles et autorisations IAM nécessaires sont correctement configurés.

Rôles Utilisateur GDC sur l'organisation :

• Facultatif : Administrateur de cluster standard (afficher les clusters depuis la console)

Utilisateur GDC sur le projet :

• Administrateur de cluster standard (standard-cluster-admin)

Utilisateur GDC sur le cluster standard :

• StandardClusterRoleBinding au StandardClusterRole cluster-admin (créé par un administrateur IAM du projet, consultez la section Identity and Access Management de l'implémentation de référence)

Station de travail

Sauf indication contraire, exécutez toutes les commandes de ce guide à partir d'un poste de travail disposant des outils requis et d'une connectivité à l'environnement et à Internet.

La configuration de l'environnement est divisée en plusieurs couches :

• ${HOME}/gdcag-solutions/env.sh charge les paramètres de la plate-forme et du registre.

• ${HOME}/gdcag-solutions/open-weight-models/vllm/env.sh ajoute les paramètres vLLM.

• Ce guide de l'utilisateur ajoute env.d/model.sh (le modèle) et env.d/accelerator.sh (l'option de GPU et les paramètres d'exécution), que vous écrivez dans la section "Modèle", ainsi que env.d/model-common.sh (les valeurs qui en découlent).

1. Créez la structure de répertoires du guide de l'utilisateur :

   mkdir -p ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d
   

2. Créez le fichier de configuration de l'environnement du modèle commun. Il dérive chaque chemin d'accès et nom de ressource de GDCS_HF_MODEL, de sorte qu'il est identique pour tous les modèles :

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/model-common.sh && echo "Successfully created." || echo "Failed to create!"
   # Model (derived from env.d/model.sh)
   export GDCS_HF_DOWNLOAD_PATH="${GDCS_USER_GUIDE_HOME}/hf-models"
   export GDCS_HF_MODEL_LOWERCASE="${GDCS_HF_MODEL,,}"
   export GDCS_HF_MODEL_DOWNLOAD_DIR="${GDCS_HF_DOWNLOAD_PATH}/${GDCS_HF_MODEL_LOWERCASE}"
   export GDCS_HF_PV_MOUNT_PATH="/mnt/hf-model"
   
   GDCS_HF_MODEL_KUBERNETES="${GDCS_HF_MODEL_LOWERCASE//\//-}"
   export GDCS_HF_MODEL_KUBERNETES="${GDCS_HF_MODEL_KUBERNETES//./-}"
   
   # Workload
   export GDCS_WORKLOAD_NAMESPACE="vllm-mistral"
   export GDCS_WORKLOAD_NAME="${GDCS_HF_MODEL_KUBERNETES}"
   export GDCS_MODEL_LOADER_POD_NAME="loader-${GDCS_HF_MODEL_KUBERNETES}"
   EOF
   

3. Créez le fichier de chargement de l'environnement du guide de l'utilisateur :

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.sh && echo "Successfully created." || echo "Failed to create!"
   source "${HOME}/gdcag-solutions/open-weight-models/vllm/env.sh"
   
   export GDCS_USER_GUIDE_HOME="${HOME}/gdcag-solutions/open-weight-models/vllm/mistral"
   echo "GDCS_USER_GUIDE_HOME=${GDCS_USER_GUIDE_HOME}"
   
   # Sourced in dependency order: the model selection, the accelerator and runtime settings, then the values derived from them
   source "${GDCS_USER_GUIDE_HOME}/env.d/model.sh"
   source "${GDCS_USER_GUIDE_HOME}/env.d/accelerator.sh"
   source "${GDCS_USER_GUIDE_HOME}/env.d/model-common.sh"
   echo "GDCS_HF_MODEL=${GDCS_HF_MODEL} (${GDCS_WORKLOAD_ACCELERATOR_COUNT} x ${GDCS_WORKLOAD_ACCELERATOR_TYPE:-unset})"
   EOF
   

Modèle

Sélectionnez le modèle et l'option de GPU qui correspondent aux nœuds GPU de votre cluster standard. GDC sous air gap propose les GPU suivants (voir Types de machines des nœuds de cluster). Le type de ressource d'accélérateur est le nom sous lequel les nœuds exposent le GPU à Kubernetes.

GPU	Mémoire	Types de machine	Type de ressource d'accélérateur
NVIDIA A100	40 Go	a2-highgpu-1g-gdc	nvidia.com/gpu-pod-NVIDIA_A100_PCIE_40GB
NVIDIA A100	80 Go	a2-ultragpu-1g-gdc, a2-ultragpu-2g-gdc	nvidia.com/gpu-pod-NVIDIA_A100_80GB_PCIE
NVIDIA H100	94 Go	a3-highgpu-1g-gdc (Preview), a3-highgpu-2g-gdc (Preview), a3-highgpu-4g-gdc	nvidia.com/gpu-pod-NVIDIA_H100_NVL
NVIDIA H200	141 Go	a3-ultragpu-8g-gdc	nvidia.com/gpu-pod-NVIDIA_H200
NVIDIA B300	288 Go	a4-ultragpu-8g-gdc	nvidia.com/gpu-pod-NVIDIA_B300_SXM6_AC

Chaque onglet liste les informations sur le modèle, la commande qui écrit le fichier d'environnement du modèle env.d/model.sh et les onglets imbriqués qui écrivent le fichier d'environnement de l'accélérateur env.d/accelerator.sh pour l'option de GPU choisie avec des types de ressources et des paramètres vLLM préremplis. Pour changer de modèle ou d'option de GPU ultérieurement, écrivez différents fichiers d'environnement, sourcez à nouveau l'environnement et répétez la section "Implémentation". Les charges de travail de plusieurs modèles peuvent s'exécuter côte à côte dans le même espace de noms, car chaque nom de ressource est dérivé du nom du modèle.

1. Créez les fichiers d'environnement du modèle et de l'accélérateur pour le modèle et l'option de GPU que vous souhaitez déployer.

   Mistral 7B Instruct

   Attribut	Valeur
   Dépôt Hugging Face	mistralai/Mistral-7B-Instruct-v0.2
   Paramètres	7,2 milliards (dense)
   Licence	Apache 2.0
   Poids utilisés par vLLM	Format Hugging Face (model-*.safetensors), environ 14,5 Go
   Longueur de contexte	32 000 jetons ; ce guide utilise --max-model-len 32768

   Créez le fichier d'environnement du modèle :

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/model.sh && echo "Successfully created." || echo "Failed to create!"
   # Model: Mistral 7B Instruct
   export GDCS_HF_MODEL="mistralai/Mistral-7B-Instruct-v0.2"
   export GDCS_HF_MODEL_REVISION="main"  # Hugging Face branch, tag, or commit to download
   export GDCS_HF_DOWNLOAD_EXCLUDE="consolidated* *.bin"
   EOF
   

   Créez le fichier d'environnement de l'accélérateur pour votre option de GPU :

   NVIDIA A100 40 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA A100 40 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_A100_PCIE_40GB"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS=""
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="60"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   NVIDIA A100 80 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA A100 80 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_A100_80GB_PCIE"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS=""
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="60"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   NVIDIA H100 94 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA H100 94 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_H100_NVL"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS=""
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="60"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   NVIDIA H200 141 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA H200 141 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_H200"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS=""
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="60"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   NVIDIA B300 288 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA B300 288 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_B300_SXM6_AC"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS=""
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="60"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   Mistral NeMo 12B Instruct

   Attribut	Valeur
   Dépôt Hugging Face	mistralai/Mistral-Nemo-Instruct-2407
   Paramètres	12B (dense)
   Licence	Apache 2.0
   Poids utilisés par vLLM	Format Mistral (consolidated.safetensors, params.json, tekken.json), environ 24,5 Go
   Longueur de contexte	128 000 jetons ; ce guide utilise --max-model-len 32768

   Remarque : vLLM détecte automatiquement le format Mistral (consolidated.safetensors, params.json, tekken.json). Le téléchargement ignore donc les segments Hugging Face model-*.safetensors. Pour diffuser des requêtes plus longues sur des GPU disposant de plus de mémoire, augmentez GDCS_VLLM_MAX_MODEL_LEN.

   Créez le fichier d'environnement du modèle :

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/model.sh && echo "Successfully created." || echo "Failed to create!"
   # Model: Mistral NeMo 12B Instruct
   export GDCS_HF_MODEL="mistralai/Mistral-Nemo-Instruct-2407"
   export GDCS_HF_MODEL_REVISION="main"  # Hugging Face branch, tag, or commit to download
   export GDCS_HF_DOWNLOAD_EXCLUDE="model-*.safetensors *.bin"
   EOF
   

   Créez le fichier d'environnement de l'accélérateur pour votre option de GPU :

   NVIDIA A100 40 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA A100 40 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_A100_PCIE_40GB"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS=""
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="180"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   NVIDIA A100 80 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA A100 80 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_A100_80GB_PCIE"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS=""
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="180"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   NVIDIA H100 94 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA H100 94 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_H100_NVL"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS=""
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="180"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   NVIDIA H200 141 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA H200 141 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_H200"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS=""
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="180"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   NVIDIA B300 288 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA B300 288 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_B300_SXM6_AC"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS=""
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="180"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   Mistral Small 3.2 24B Instruct

   Attribut	Valeur
   Dépôt Hugging Face	mistralai/Mistral-Small-3.2-24B-Instruct-2506
   Paramètres	24B (dense, avec encodeur visuel)
   Licence	Apache 2.0
   Poids utilisés par vLLM	Format Mistral (consolidated.safetensors, params.json, tekken.json), environ 48 Go
   Longueur de contexte	128 000 jetons ; ce guide utilise --max-model-len 32768

   Remarque : vLLM détecte automatiquement le format Mistral (consolidated.safetensors, params.json, tekken.json). Le téléchargement ignore donc les segments Hugging Face model-*.safetensors.

   Créez le fichier d'environnement du modèle :

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/model.sh && echo "Successfully created." || echo "Failed to create!"
   # Model: Mistral Small 3.2 24B Instruct
   export GDCS_HF_MODEL="mistralai/Mistral-Small-3.2-24B-Instruct-2506"
   export GDCS_HF_MODEL_REVISION="main"  # Hugging Face branch, tag, or commit to download
   export GDCS_HF_DOWNLOAD_EXCLUDE="model-*.safetensors *.bin"
   EOF
   

   Créez le fichier d'environnement de l'accélérateur pour votre option de GPU :

   NVIDIA A100 80 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA A100 80 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_A100_80GB_PCIE"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS=""
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="300"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   NVIDIA H100 94 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA H100 94 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_H100_NVL"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS=""
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="300"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   NVIDIA H200 141 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA H200 141 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_H200"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS=""
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="300"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   NVIDIA B300 288 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA B300 288 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_B300_SXM6_AC"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS=""
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="300"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   Ministral 8B Instruct

   Attribut	Valeur
   Dépôt Hugging Face	mistralai/Ministral-8B-Instruct-2410
   Paramètres	8B (dense)
   Licence	Licence de recherche Mistral AI (utilisation à des fins de recherche et non commerciale uniquement)
   Poids utilisés par vLLM	Format Mistral (consolidated.safetensors, params.json, tekken.json), environ 16 Go
   Longueur de contexte	128 000 jetons ; ce guide utilise --max-model-len 32768

   Remarque : vLLM détecte automatiquement le format Mistral (consolidated.safetensors, params.json, tekken.json). Le téléchargement ignore donc les segments Hugging Face model-*.safetensors.

   Remarque : La licence de recherche Mistral AI n'autorise que la recherche et l'utilisation non commerciale. Obtenez une licence commerciale auprès de Mistral AI avant d'utiliser Ministral 8B en production.

   Créez le fichier d'environnement du modèle :

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/model.sh && echo "Successfully created." || echo "Failed to create!"
   # Model: Ministral 8B Instruct
   export GDCS_HF_MODEL="mistralai/Ministral-8B-Instruct-2410"
   export GDCS_HF_MODEL_REVISION="main"  # Hugging Face branch, tag, or commit to download
   export GDCS_HF_DOWNLOAD_EXCLUDE="model-*.safetensors *.bin"
   EOF
   

   Créez le fichier d'environnement de l'accélérateur pour votre option de GPU :

   NVIDIA A100 40 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA A100 40 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_A100_PCIE_40GB"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS=""
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="120"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   NVIDIA A100 80 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA A100 80 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_A100_80GB_PCIE"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS=""
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="120"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   NVIDIA H100 94 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA H100 94 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_H100_NVL"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS=""
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="120"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   NVIDIA H200 141 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA H200 141 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_H200"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS=""
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="120"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   NVIDIA B300 288 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA B300 288 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_B300_SXM6_AC"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS=""
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="120"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   Mixtral 8x7B Instruct

   Attribut	Valeur
   Dépôt Hugging Face	mistralai/Mixtral-8x7B-Instruct-v0.1
   Paramètres	46,7 milliards au total / 12,9 milliards actifs (Mixture of Experts, 8x7B)
   Licence	Apache 2.0
   Poids utilisés par vLLM	Format Hugging Face (model-*.safetensors), environ 93 Go (le dépôt contient également des fichiers PyTorch consolidated.*.pt, exclus)
   Longueur de contexte	32 000 jetons ; ce guide utilise --max-model-len 32768

   Remarque : Mixtral est un modèle de mélange d'experts (8 experts, 2 actifs par jeton) : environ 12,9 milliards de paramètres sont actifs par jeton, mais les 46,7 milliards doivent résider dans la mémoire GPU. Les pondérations bf16 (environ 93 Go) ne tiennent pas sur un seul GPU de 80 Go ou 94 Go : utilisez deux GPU (parallélisme de tenseur), une quantification FP8 basée uniquement sur les pondérations sur un GPU, ou un GPU H200 ou B300.

   Créez le fichier d'environnement du modèle :

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/model.sh && echo "Successfully created." || echo "Failed to create!"
   # Model: Mixtral 8x7B Instruct
   export GDCS_HF_MODEL="mistralai/Mixtral-8x7B-Instruct-v0.1"
   export GDCS_HF_MODEL_REVISION="main"  # Hugging Face branch, tag, or commit to download
   export GDCS_HF_DOWNLOAD_EXCLUDE="consolidated* *.bin"
   EOF
   

   Créez le fichier d'environnement de l'accélérateur pour votre option de GPU :

   NVIDIA A100 80 Go (2 GPU)

   Nécessite un nœud avec deux GPU A100 80 Go (a2-ultragpu-2g-gdc). vLLM s'exécute avec --tensor-parallel-size 2.

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA A100 80 GB (2 GPUs)
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_A100_80GB_PCIE"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="2"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS=""
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="480"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   NVIDIA H100 94 Go (2 GPU)

   Nécessite un nœud avec au moins deux GPU H100 (a3-highgpu-2g-gdc ou a3-highgpu-4g-gdc) ; vLLM s'exécute avec --tensor-parallel-size 2.

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA H100 94 GB (2 GPUs)
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_H100_NVL"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="2"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS=""
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="480"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   NVIDIA A100 80 Go (FP8)

   --quantization=fp8 quantifie les pondérations en FP8 lors du chargement (environ 47 Go au lieu de 93 Go), avec une qualité de sortie légèrement inférieure.

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA A100 80 GB (FP8)
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_A100_80GB_PCIE"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS="--quantization=fp8"
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="480"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   NVIDIA H100 94 Go (FP8)

   --quantization=fp8 quantifie les pondérations en FP8 lors du chargement (environ 47 Go au lieu de 93 Go), avec une qualité de sortie légèrement inférieure.

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA H100 94 GB (FP8)
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_H100_NVL"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS="--quantization=fp8"
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="480"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   NVIDIA H200 141 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA H200 141 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_H200"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS=""
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="480"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   NVIDIA B300 288 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA B300 288 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_B300_SXM6_AC"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="32768"
   export GDCS_VLLM_EXTRA_ARGS=""
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="480"
   export GDCS_VLLM_TEST_MAX_TOKENS="128"
   EOF
   

   Magistral Small 1.2 24B

   Attribut	Valeur
   Dépôt Hugging Face	mistralai/Magistral-Small-2509
   Paramètres	24B (dense, raisonnement, avec encodeur visuel)
   Licence	Apache 2.0
   Poids utilisés par vLLM	Format Mistral (consolidated.safetensors, params.json, tekken.json), environ 48 Go
   Longueur de contexte	128 000 jetons (40 000 recommandés par Mistral) ; ce guide utilise --max-model-len 40960

   Remarque : vLLM détecte automatiquement le format Mistral (consolidated.safetensors, params.json, tekken.json). Le téléchargement ignore donc les segments Hugging Face model-*.safetensors.

   Remarque : Magistral Small 1.2 est un modèle de raisonnement. Il ne raisonne que lorsque la requête inclut le prompt système recommandé par Mistral (SYSTEM_PROMPT.txt, importé dans le PersistentVolume avec les pondérations). vLLM renvoie ensuite le raisonnement dans message.reasoning_content et la réponse dans message.content. Le raisonnement consomme des jetons de sortie. Ce guide définit donc un GDCS_VLLM_TEST_MAX_TOKENS plus élevé.

   Créez le fichier d'environnement du modèle :

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/model.sh && echo "Successfully created." || echo "Failed to create!"
   # Model: Magistral Small 1.2 24B
   export GDCS_HF_MODEL="mistralai/Magistral-Small-2509"
   export GDCS_HF_MODEL_REVISION="main"  # Hugging Face branch, tag, or commit to download
   export GDCS_HF_DOWNLOAD_EXCLUDE="model-*.safetensors *.bin"
   EOF
   

   Créez le fichier d'environnement de l'accélérateur pour votre option de GPU :

   NVIDIA A100 80 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA A100 80 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_A100_80GB_PCIE"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="40960"
   export GDCS_VLLM_EXTRA_ARGS="--reasoning-parser=mistral"
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="300"
   export GDCS_VLLM_TEST_MAX_TOKENS="1024"
   EOF
   

   NVIDIA H100 94 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA H100 94 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_H100_NVL"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="40960"
   export GDCS_VLLM_EXTRA_ARGS="--reasoning-parser=mistral"
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="300"
   export GDCS_VLLM_TEST_MAX_TOKENS="1024"
   EOF
   

   NVIDIA H200 141 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA H200 141 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_H200"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="40960"
   export GDCS_VLLM_EXTRA_ARGS="--reasoning-parser=mistral"
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="300"
   export GDCS_VLLM_TEST_MAX_TOKENS="1024"
   EOF
   

   NVIDIA B300 288 Go

   cat << 'EOF' > ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.d/accelerator.sh && echo "Successfully created." || echo "Failed to create!"
   # Accelerator: NVIDIA B300 288 GB
   export GDCS_WORKLOAD_ACCELERATOR_TYPE="nvidia.com/gpu-pod-NVIDIA_B300_SXM6_AC"
   export GDCS_WORKLOAD_ACCELERATOR_COUNT="1"
   
   # vLLM
   export GDCS_VLLM_MAX_MODEL_LEN="40960"
   export GDCS_VLLM_EXTRA_ARGS="--reasoning-parser=mistral"
   export GDCS_VLLM_STARTUP_FAILURE_THRESHOLD="300"
   export GDCS_VLLM_TEST_MAX_TOKENS="1024"
   EOF
   

2. Sourcez le fichier d'environnement :

   source ${HOME}/gdcag-solutions/open-weight-models/vllm/mistral/env.sh
   

   Le résultat ressemble à ce qui suit :

   GDCS_ROOT_HOME=HOME_DIRECTORY_PATH/gdcag-solutions
   GDCS_IMPLEMENTATION_HOME=HOME_DIRECTORY_PATH/gdcag-solutions/open-weight-models/vllm
   GDCS_USER_GUIDE_HOME=HOME_DIRECTORY_PATH/gdcag-solutions/open-weight-models/vllm/mistral
   GDCS_HF_MODEL=HUGGING_FACE_REPOSITORY (ACCELERATOR_COUNT x ACCELERATOR_RESOURCE_TYPE)
   

Remarque : Chaque fois qu'un nouveau terminal ou shell est démarré, le fichier d'environnement doit être sourcé.

Cluster

1. Configurez gdcloud :

   gdcloud config set core/account "default-user"
   gdcloud config set core/organization_console_url "${GDC_ZONAL_CONSOLE_URL}"
   gdcloud config set core/project "${GDC_PROJECT}"
   gdcloud config set core/zone "${GDC_ZONE}"
   

2. Authentifiez-vous auprès de l'environnement GDC :

   gdcloud auth login
   

3. Récupérez les identifiants du cluster :

   gdcloud clusters get-credentials "${GDC_STANDARD_CLUSTER_NAME}" \
   --project="${GDC_PROJECT}" \
   --standard \
   --zone="${GDC_ZONE}"
   

4. Vérifiez la connectivité au cluster :

   kubectl get nodes -L node.cluster.private.gdc.goog/machine-class
   

5. Vérifiez que le type de ressource d'accélérateur du fichier d'environnement de l'accélérateur est disponible dans le cluster. La commande liste les types de ressources d'accélérateur exposés par les nœuds (le nom dépend du modèle de GPU installé ; il est vide sur les clusters sans nœuds GPU) et la valeur configurée :

   kubectl get nodes --output=json | jq -r '[.items[].status.allocatable | keys[] | select(startswith("nvidia.com/"))] | unique[]'
   echo "GDCS_WORKLOAD_ACCELERATOR_TYPE=${GDCS_WORKLOAD_ACCELERATOR_TYPE}"
   

   Remarque : Si la valeur configurée ne figure pas dans la liste, définissez GDCS_WORKLOAD_ACCELERATOR_TYPE dans env.d/accelerator.sh sur l'un des types de ressources répertoriés, puis sourcez à nouveau le fichier d'environnement.

Implémentation

Espace de noms

1. Créez l'espace de noms :

   kubectl create namespace "${GDCS_WORKLOAD_NAMESPACE}" \
   --dry-run=client \
   --output=yaml | kubectl apply -f -
   

2. Ajoutez le imagePullSecret :

   kubectl create secret docker-registry "${GDCS_HARBOR_K8S_PULL_SECRET}" \
   --dry-run=client \
   --from-file=.dockerconfigjson=${GDCS_HARBOR_K8S_DOCKER_CONFIG}/config.json \
   --namespace="${GDCS_WORKLOAD_NAMESPACE}" \
   --output=yaml | kubectl apply -f -
   

Pondérations de modèle

1. Téléchargez les pondérations du modèle (uniquement les fichiers dont vLLM a besoin pour le modèle sélectionné, GDCS_HF_DOWNLOAD_EXCLUDE ignore le reste) et supprimez le répertoire .cache :

   EXCLUDE_ARGS=()
   if [[ -n "${GDCS_HF_DOWNLOAD_EXCLUDE:-}" ]]; then
     read -r -a EXCLUDE_PATTERNS <<< "${GDCS_HF_DOWNLOAD_EXCLUDE}"
     EXCLUDE_ARGS=(--exclude "${EXCLUDE_PATTERNS[@]}")
   fi
   hf download "${GDCS_HF_MODEL}" --revision "${GDCS_HF_MODEL_REVISION}" --local-dir "${GDCS_HF_MODEL_DOWNLOAD_DIR}" "${EXCLUDE_ARGS[@]}" && \
   rm -rf "${GDCS_HF_MODEL_DOWNLOAD_DIR}/.cache"
   

2. Calculez la taille de PersistentVolumeClaim requise à partir des pondérations du modèle téléchargé avec une surcharge de 25 % (arrondie au Gio entier supérieur) :

   MODEL_KIB=$(du -sk "${GDCS_HF_MODEL_DOWNLOAD_DIR}" | awk '{print $1}')
   export GDCS_MODEL_PVC_SIZE="$(( (MODEL_KIB * 125 / 100 + 1048575) / 1048576 ))Gi"
   echo "GDCS_MODEL_PVC_SIZE=${GDCS_MODEL_PVC_SIZE}"
   

3. Créez le fichier manifeste du PersistentVolumeClaim ReadWriteOnce pour les pondérations du modèle :

   cat <<EOF > "${GDCS_USER_GUIDE_HOME}/${GDCS_WORKLOAD_NAME}-rwo-pvc.yaml"
   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: ${GDCS_WORKLOAD_NAME}-rwo
   spec:
     accessModes:
       - ReadWriteOnce
     resources:
       requests:
         storage: ${GDCS_MODEL_PVC_SIZE}
     storageClassName: standard-rwo
     volumeMode: Filesystem
   EOF
   

4. Appliquez le fichier manifeste pour le PersistentVolumeClaim des pondérations du modèle :

   kubectl apply \
   --filename="${GDCS_USER_GUIDE_HOME}/${GDCS_WORKLOAD_NAME}-rwo-pvc.yaml" \
   --namespace="${GDCS_WORKLOAD_NAMESPACE}"
   

5. Attendez que PersistentVolumeClaim lie et affiche les valeurs dont l'opérateur d'infrastructure a besoin pour ajuster la règle de qualité de service (QoS) des E/S :

   kubectl wait \
   --for=jsonpath='{.status.phase}'=Bound \
   "pvc/${GDCS_WORKLOAD_NAME}-rwo" \
   --namespace="${GDCS_WORKLOAD_NAMESPACE}" \
   --timeout=120s
   BACKING_PVC=$(kubectl get pvc "${GDCS_WORKLOAD_NAME}-rwo" \
   --namespace="${GDCS_WORKLOAD_NAMESPACE}" \
   --output=jsonpath='{.spec.volumeName}')
   echo "BACKING_PVC=${BACKING_PVC} ORG=${GDC_ORG}"
   

6. Si performance-rwo n'est pas disponible sur votre cluster, demandez à votre opérateur d'infrastructure d'appliquer la règle de QoS hautes performances (system-performance-<ORG>-admin, 30 IOPS par Gio avec un seuil minimal de 6 148 IOPS) au volume qui sauvegarde le PersistentVolumeClaim. Indiquez les valeurs BACKING_PVC et ORG affichées à l'étape précédente. L'opérateur d'infrastructure applique la règle comme décrit dans FILE-R0097. Elle prend effet sur le volume actif, ce qui vous permet de passer aux étapes suivantes.

   Remarque : Si le stockage de blocs hautes performances est activé sur votre cluster, vous pouvez définir storageClassName: performance-rwo dans le fichier manifeste PersistentVolumeClaim au lieu de demander la règle de QoS. Si kubectl get storageclass performance-rwo ne renvoie rien, l'opérateur d'infrastructure n'a pas activé le stockage de blocs hautes performances.

7. Créez le fichier manifeste pour le pod du chargeur de modèle :

   cat <<EOF > "${GDCS_USER_GUIDE_HOME}/${GDCS_MODEL_LOADER_POD_NAME}-pod.yaml"
   apiVersion: v1
   kind: Pod
   metadata:
     name: ${GDCS_MODEL_LOADER_POD_NAME}
   spec:
     containers:
       - name: uploader
         image: ${GDCS_HARBOR_PROJECT_URI}/library/busybox:${GDCS_BUSYBOX_IMAGE_TAG}
         command: ["sleep", "infinity"]
         volumeMounts:
           - name: model-data
             mountPath: ${GDCS_HF_PV_MOUNT_PATH}
     imagePullSecrets:
       - name: ${GDCS_HARBOR_K8S_PULL_SECRET}
     volumes:
       - name: model-data
         persistentVolumeClaim:
           claimName: ${GDCS_WORKLOAD_NAME}-rwo
   EOF
   

8. Appliquez le fichier manifeste pour le pod du chargeur de modèle :

   kubectl apply \
   --filename="${GDCS_USER_GUIDE_HOME}/${GDCS_MODEL_LOADER_POD_NAME}-pod.yaml" \
   --namespace="${GDCS_WORKLOAD_NAMESPACE}"
   

9. Attendez que le pod du chargeur de modèle soit en cours d'exécution :

   watch --color --interval 5 --no-title \
   "kubectl get pod/${GDCS_MODEL_LOADER_POD_NAME} \
   --namespace=${GDCS_WORKLOAD_NAMESPACE} | GREP_COLORS='mt=01;92' grep -E --color=always -e '^' -e 'Running'"
   

10. Importez les pondérations du modèle dans PersistentVolume (le script ignore les fichiers qui existent déjà avec la même taille, il peut donc être réexécuté) :

    export LOCAL_MODEL_DIR="${GDCS_HF_MODEL_DOWNLOAD_DIR}"
    export REMOTE_MODEL_DIR="${GDCS_HF_PV_MOUNT_PATH}/${GDCS_HF_MODEL_LOWERCASE}"
    export REMOTE_MOUNT_DIR="${GDCS_HF_PV_MOUNT_PATH}"
    
    ${GDCS_IMPLEMENTATION_HOME}/model_weight_upload.sh
    

11. Supprimez le pod du chargeur de modèle :

    kubectl delete pod/${GDCS_MODEL_LOADER_POD_NAME} \
    --namespace="${GDCS_WORKLOAD_NAMESPACE}"
    

Serveur d'inférence

1. Créez le fichier manifeste pour le déploiement vLLM. Le ConfigMap contient les paramètres vLLM spécifiques au modèle de l'environnement. Le fichier manifeste est donc le même pour chaque modèle et option de GPU :

   cat <<EOF > "${GDCS_USER_GUIDE_HOME}/${GDCS_WORKLOAD_NAME}-deployment.yaml"
   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: ${GDCS_WORKLOAD_NAME}
   data:
     MAX_MODEL_LEN: "${GDCS_VLLM_MAX_MODEL_LEN}"
     MODEL: "${GDCS_HF_PV_MOUNT_PATH}/${GDCS_HF_MODEL_LOWERCASE}"
     PORT: "8000"
     TENSOR_PARALLEL_SIZE: "${GDCS_WORKLOAD_ACCELERATOR_COUNT}"
     VLLM_EXTRA_ARGS: "${GDCS_VLLM_EXTRA_ARGS}"
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: ${GDCS_WORKLOAD_NAME}
     labels:
       app: ${GDCS_WORKLOAD_NAME}
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: ${GDCS_WORKLOAD_NAME}
     strategy:
       type: Recreate
     template:
       metadata:
         labels:
           app: ${GDCS_WORKLOAD_NAME}
       spec:
         containers:
           - command:
               - /bin/sh
               - -c
             args:
               - exec vllm serve "\$MODEL" --port="\$PORT" --tensor-parallel-size="\$TENSOR_PARALLEL_SIZE" --max-model-len="\$MAX_MODEL_LEN" \$VLLM_EXTRA_ARGS
             envFrom:
               - configMapRef:
                   name: ${GDCS_WORKLOAD_NAME}
             image: ${GDCS_HARBOR_PROJECT_URI}/vllm/vllm-openai:${GDCS_VLLM_IMAGE_TAG}-fips
             livenessProbe:
               failureThreshold: 3
               httpGet:
                 path: /health
                 port: 8000
               periodSeconds: 20
               timeoutSeconds: 5
             name: vllm
             ports:
               - containerPort: 8000
             readinessProbe:
               failureThreshold: 3
               httpGet:
                 path: /health
                 port: 8000
               periodSeconds: 10
               successThreshold: 1
               timeoutSeconds: 5
             resources:
               limits:
                 ${GDCS_WORKLOAD_ACCELERATOR_TYPE}: "${GDCS_WORKLOAD_ACCELERATOR_COUNT}"
               requests:
                 ${GDCS_WORKLOAD_ACCELERATOR_TYPE}: "${GDCS_WORKLOAD_ACCELERATOR_COUNT}"
             startupProbe:
               httpGet:
                 path: /health
                 port: 8000
               failureThreshold: ${GDCS_VLLM_STARTUP_FAILURE_THRESHOLD}
               periodSeconds: 10
               timeoutSeconds: 5
             volumeMounts:
               - name: model-weights
                 mountPath: ${GDCS_HF_PV_MOUNT_PATH}
               - name: shm
                 mountPath: /dev/shm
         securityContext:
           seLinuxOptions:
             type: spc_t
         imagePullSecrets:
           - name: ${GDCS_HARBOR_K8S_PULL_SECRET}
         volumes:
           - name: model-weights
             persistentVolumeClaim:
               claimName: ${GDCS_WORKLOAD_NAME}-rwo
           - name: shm
             emptyDir:
               medium: Memory
               sizeLimit: "8Gi"
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: ${GDCS_WORKLOAD_NAME}
   spec:
     ports:
       - name: vllm-http
         port: 80
         protocol: TCP
         targetPort: 8000
     selector:
       app: ${GDCS_WORKLOAD_NAME}
     type: LoadBalancer
   EOF
   

   Remarque : La vérification de démarrage accorde GDCS_VLLM_STARTUP_FAILURE_THRESHOLD x 10 secondes à vLLM pour charger les pondérations et compiler les graphiques CUDA. Le fichier d'environnement de l'accélérateur (env.d/accelerator.sh) définit une valeur qui correspond à la taille du modèle. Le format exec vllm serve ajoute les VLLM_EXTRA_ARGS séparés par des espaces en tant qu'arguments individuels. Les valeurs ne doivent donc pas contenir de guillemets. Utilisez le format avec point de vLLM pour les options de type JSON, par exemple --limit-mm-per-prompt.image=0.

2. Appliquez le fichier manifeste pour le déploiement vLLM :

   kubectl apply \
   --filename="${GDCS_USER_GUIDE_HOME}/${GDCS_WORKLOAD_NAME}-deployment.yaml" \
   --namespace="${GDCS_WORKLOAD_NAMESPACE}"
   

3. Créez le fichier manifeste pour le NetworkPolicy vLLM :

   cat << EOF > "${GDCS_USER_GUIDE_HOME}/vllm-networkpolicy.yaml" && echo "Successfully created." || echo "Failed to create!"
   apiVersion: networking.k8s.io/v1
   kind: NetworkPolicy
   metadata:
     name: allow-vllm-ingress
     namespace: ${GDCS_WORKLOAD_NAMESPACE}
   spec:
     ingress:
     - from:
       - ipBlock:
           cidr: 0.0.0.0/0
       - namespaceSelector: {}
       ports:
       - port: 8000
         protocol: TCP
     podSelector: {}
     policyTypes:
     - Ingress
   EOF
   

4. Appliquez le fichier manifeste pour le NetworkPolicy vLLM :

   kubectl apply \
   --filename="${GDCS_USER_GUIDE_HOME}/vllm-networkpolicy.yaml"
   

Remarque : NetworkPolicy accepte le trafic provenant de n'importe quelle source vers le port de la charge de travail à l'intérieur du cluster. Pour accéder à l'adresse IP de l'équilibreur de charge depuis l'extérieur du projet, vous devez également disposer d'une ProjectNetworkPolicy (networking.gdc.goog/v1) créée dans l'espace de noms du projet par un administrateur de NetworkPolicy de projet. Consultez Configurer des règles de réseau de projet.

1. Attendez que le pod soit en cours d'exécution :

   watch --color --interval 5 --no-title \
   "kubectl get pods --selector=app=${GDCS_WORKLOAD_NAME} \
   --namespace=${GDCS_WORKLOAD_NAMESPACE} | GREP_COLORS='mt=01;92' grep -E --color=always -e '^' -e 'Running'"
   

2. Attendez que le déploiement soit prêt :

   watch --color --interval 5 --no-title \
   "kubectl get deployment/${GDCS_WORKLOAD_NAME} \
   --namespace=${GDCS_WORKLOAD_NAMESPACE} | GREP_COLORS='mt=01;92' grep -E --color=always -e '^' -e '1/1     1            1'"
   

3. Facultatif : Diffusez les journaux du conteneur pour surveiller la progression du démarrage :

   kubectl logs deployment/${GDCS_WORKLOAD_NAME} \
   --follow \
   --namespace="${GDCS_WORKLOAD_NAMESPACE}"
   

Validation

1. Récupérez l'adresse IP de l'équilibreur de charge pour vLLM :

   export VLLM_LB_IP=$(kubectl get service/${GDCS_WORKLOAD_NAME} --namespace="${GDCS_WORKLOAD_NAMESPACE}" --output=jsonpath='{.status.loadBalancer.ingress[*].ip}')
   echo "VLLM_LB_IP=${VLLM_LB_IP}"
   

2. Envoyez une requête de test à vLLM. La valeur max_tokens est GDCS_VLLM_TEST_MAX_TOKENS de env.d/accelerator.sh. Les modèles de raisonnement ont besoin d'un budget plus important, car la phase de raisonnement consomme des jetons de sortie :

   curl http://${VLLM_LB_IP}/v1/models
   
   curl http://${VLLM_LB_IP}/v1/chat/completions \
   -H "Content-Type: application/json" \
   -d '{
     "model": "'${GDCS_HF_PV_MOUNT_PATH}/${GDCS_HF_MODEL_LOWERCASE}'",
     "messages": [
       {"role": "user", "content": "Explain Google Distributed Cloud air-gapped briefly."}
     ],
     "max_tokens": '${GDCS_VLLM_TEST_MAX_TOKENS}'
   }'
   

   Remarque : Si vous envoyez le prompt système de Mistral à Magistral Small 1.2 et que content est vide avec finish_reason: length, augmentez max_tokens.

3. Si l'adresse IP de l'équilibreur de charge n'est pas accessible depuis le poste de travail, par exemple parce qu'aucun ProjectNetworkPolicy ne l'accepte encore, envoyez les requêtes via le transfert de port :

   kubectl port-forward service/${GDCS_WORKLOAD_NAME} \
   --namespace="${GDCS_WORKLOAD_NAMESPACE}" 8000:80 &
   PF_PID=$!
   
   sleep 1
   
   curl http://127.0.0.1:8000/v1/models
   
   kill ${PF_PID}