DevOps / CI/CD

RTX 5090 : faut-il CUDA 13.5 pour faire tourner vLLM ? Dépannage de l’environnement 2026

Erreur CUDA au démarrage, extension vLLM impossible à importer ou modèle FP4 qui échoue au chargement sur RTX 5090 ?

Décision : ne partez pas du principe que CUDA 13.5 est requis. Au 30 septembre 2026, l’archive officielle de NVIDIA indique CUDA 13.4.1 comme version la plus récente répertoriée, tandis que les options de construction visibles dans les ressources officielles de vLLM comprennent CUDA 12.8, 12.9 et 13.0. Choisissez selon la combinaison réellement utilisée — pilote, environnement PyTorch et version de vLLM — plutôt qu’en poursuivant un numéro de version supposé obligatoire (archive CUDA de NVIDIA, instructions d’installation CUDA de vLLM et versions publiées par vLLM).

Cet article s’adresse aux développeurs qui installent ou mettent à niveau vLLM sur RTX 5090, aux ingénieurs qui essaient un modèle volumineux ou quantifié, et aux équipes qui doivent départager un problème de conteneur, de PyTorch ou de CUDA.

Dernière vérification : 30 septembre 2026, à partir de l’archive CUDA, des ressources d’installation et de publication de vLLM, ainsi que des informations officielles de Meta sur Llama 4. Ces références peuvent évoluer : revérifiez-les avant de figer une image ou une procédure de déploiement.

Établir d’abord le périmètre des versions

La mention « CUDA 13.5 » ne suffit pas à choisir une installation. Un numéro affiché par un outil, une version de bibliothèque présente dans un conteneur et la version CUDA utilisée pour construire un paquet PyTorch ne décrivent pas nécessairement le même élément. Une incompatibilité peut donc apparaître même si chaque composant semble, pris isolément, récent.

À la date de vérification, l’archive NVIDIA liste CUDA 13.4.1. De son côté, la documentation d’installation et les notes de publication de vLLM consultées proposent des choix de construction comprenant CUDA 12.8, 12.9 et 13.0 ; cela ne confirme pas que CUDA 13.5 est nécessaire pour faire fonctionner vLLM sur RTX 5090. Ces informations décrivent des options publiées, pas une garantie universelle que toutes les combinaisons fonctionnent avec toutes les versions.

Option examinée Ce qu’elle permet de conclure Vérification avant de choisir
Installer CUDA 13.5 parce qu’un message d’erreur le suggère Rien ne prouve, à lui seul, que cette version soit requise par RTX 5090 ou vLLM Identifier le composant qui affiche l’erreur et confronter sa version aux instructions de l’édition utilisée
Choisir une construction vLLM annoncée pour CUDA 12.8, 12.9 ou 13.0 Ces options apparaissent dans les ressources officielles consultées ; elles ne sont pas interchangeables par défaut Vérifier l’édition de vLLM, le paquet PyTorch et l’environnement CUDA associés dans la documentation correspondante
Partir d’un conteneur publié pour une combinaison précise Le conteneur peut fournir un ensemble cohérent de composants, selon son contenu et son étiquette Contrôler son étiquette, le pilote de l’hôte et les instructions de la version retenue

La compatibilité entre pilote et environnement CUDA dépend également des règles NVIDIA : la documentation sur la compatibilité mineure CUDA décrit des conditions à respecter, mais elle ne remplace pas la vérification de la pile logicielle attendue par vLLM. Dans un conteneur, ne déduisez donc pas la version utilisée par l’application du seul résultat d’une commande exécutée sur l’hôte.

Avant de modifier quoi que ce soit, consignez dans un relevé unique le modèle de GPU reconnu, la version du pilote, le type d’environnement — installation sur l’hôte ou conteneur —, la version et le paquet PyTorch, le backend CUDA indiqué par PyTorch, la version de vLLM et la provenance de son installation. Cette ligne de base rend les comparaisons utiles : sans elle, une mise à jour simultanée du pilote, de PyTorch et de vLLM empêche de savoir quelle modification a corrigé ou créé l’incident.

Repérer une incompatibilité avant de reconstruire l’environnement

Pour installer vLLM sur RTX 5090, quel choix CUDA retenir ? Retenez celui qui correspond à l’édition de vLLM et au paquet PyTorch effectivement installés ; ne sélectionnez pas un numéro isolé parce qu’il est supérieur à celui d’un tutoriel. La page d’installation officielle de vLLM est la référence à vérifier pour la version visée. Si les indications concernent une autre édition que celle de l’environnement, elles ne constituent pas une preuve de compatibilité.

Les échecs d’installation, d’importation et de démarrage n’indiquent pas tous la même panne. Une installation interrompue peut venir d’un paquet indisponible pour la combinaison choisie, d’une construction locale qui échoue ou d’un conflit de dépendances. Une extension qui ne s’importe pas peut signaler un décalage entre le binaire installé, PyTorch et les bibliothèques attendues. Un processus qui démarre puis échoue lors de l’initialisation du GPU oriente vers d’autres vérifications, notamment le pilote et l’accès au périphérique.

Symptôme observé Vérification prioritaire Test discriminant
L’installation s’interrompt ou ne trouve pas de paquet adapté Provenance du paquet et combinaison prévue par la documentation vLLM Comparer l’option d’installation à la page officielle correspondant à la version utilisée
L’importation d’une extension CUDA échoue Versions et provenance de PyTorch et de vLLM ; présence d’un mélange entre paquet préconstruit et compilation locale Refaire un essai dans un environnement propre, sans changer le pilote en même temps
vLLM s’importe, mais le démarrage échoue à l’initialisation du GPU Pilote, accès GPU depuis le conteneur et correspondance avec le moteur d’exécution Lancer un test minimal d’accès au GPU avant d’ouvrir le modèle
Le serveur démarre, mais un modèle précis ne charge pas Format des poids, architecture prise en charge et mémoire disponible Tester un modèle de référence compatible avec la version de vLLM, puis réintroduire le modèle cible

Comment distinguer un problème PyTorch d’une incompatibilité CUDA lorsque la compilation échoue ? Commencez par relever le backend CUDA exposé par PyTorch, puis comparez-le à la construction de vLLM et à la version de pilote disponible sur l’hôte. Si PyTorch ne reconnaît pas le GPU ou ne peut pas exécuter son test minimal, l’erreur précède le diagnostic de vLLM. Si PyTorch fonctionne mais que l’importation d’une extension vLLM échoue, examinez d’abord la provenance du paquet vLLM et son adéquation à cet environnement, plutôt que de remplacer CUDA à l’aveugle.

Le pilote et la boîte à outils CUDA ne sont pas synonymes : la compatibilité mineure documentée par NVIDIA est soumise à des conditions et ne signifie pas que toute combinaison de bibliothèques applicatives est valide. De même, une version de CUDA installée sur l’hôte ne prouve pas que PyTorch dans un conteneur utilise ce même ensemble de bibliothèques. Pour limiter les coûts de diagnostic, gardez le pilote inchangé pendant la comparaison de deux constructions et ne faites varier qu’un élément à la fois.

Une procédure d’installation unique ne peut donc pas être recommandée pour toutes les versions. Avant de reconstruire, vérifiez dans les documents officiels la commande ou l’image destinée à l’édition retenue, puis notez si vLLM provient d’un paquet préconstruit, d’une image ou d’une compilation locale. Si l’installation actuelle a été assemblée à partir de sources différentes, mieux vaut établir un environnement témoin documenté que continuer à empiler des correctifs.

Diagnostiquer séparément les erreurs de modèle FP4

Lorsqu’un modèle FP4 échoue à charger, que faut-il vérifier en premier ? Il faut identifier le format précis déclaré par la configuration des poids, la chaîne de quantification utilisée et la prise en charge de cette représentation par le backend et la version de vLLM. L’étiquette « 4 bits » ne suffit pas à établir qu’un modèle est compatible.

NVFP4 est un format flottant à quatre bits, distinct d’une quantification INT4, qui représente les valeurs selon une logique entière. Les deux approches ne désignent donc pas une représentation interchangeable, même si leur nom comporte la même largeur nominale. Les documents de vLLM sur le choix du schéma NVFP4 et les points de contrôle pris en charge par ModelOpt permettent de vérifier les formats et les chemins pris en charge par le projet. Le soutien à un format ne garantit pas que chaque modèle portant une étiquette similaire fonctionne dans chaque configuration.

Distinguez ensuite trois familles d’échec. Un message indiquant un fichier ou une configuration de quantification introuvable relève d’abord de la structure du modèle ou d’un artefact incomplet. Une erreur d’opérateur ou de noyau signale plutôt un chemin d’exécution qui ne prend pas en charge le format ou l’architecture dans la configuration présente. Enfin, un modèle qui charge mais produit des sorties incohérentes exige un examen distinct : vérifiez les paramètres de quantification, les fichiers associés et les transformations appliquées au modèle, puis comparez avec une configuration de référence. Ne concluez pas à une corruption des poids sur la seule base d’une sortie inattendue.

La quantification nominale ne permet pas non plus de calculer seule la mémoire réellement nécessaire. Les poids peuvent s’accompagner d’échelles, de métadonnées et d’autres éléments, tandis que le chargement et la génération sollicitent aussi des espaces de travail et le cache KV. Une taille de fichier ou une division directe du nombre de paramètres par le nombre de bits peut servir d’ordre de grandeur théorique sous hypothèses explicites, mais pas de preuve que le modèle tiendra en mémoire ni que le moteur possède le chemin d’exécution requis.

Consignez le nom du format tel qu’il est déclaré par les fichiers du modèle, la méthode de quantification et la version de vLLM. Si ces renseignements manquent, arrêtez le diagnostic à cette étape : essayer plusieurs réglages de lancement sans savoir si les poids sont en NVFP4, INT4 ou dans une autre représentation confond compatibilité de format, disponibilité des opérateurs et pression mémoire.

Isoler les problèmes de préremplissage par blocs

Après activation de Chunked Prefill, comment départager une anomalie de planification d’un manque de mémoire ? Comparez d’abord le même modèle et le même scénario avec Chunked Prefill désactivé, ou avec un réglage documenté différent pour la version utilisée. Conservez les autres paramètres identiques, puis notez la longueur du prompt, le nombre de requêtes simultanées et la limite de jetons de lot. Si l’erreur disparaît uniquement lors de cette comparaison, le chemin de traitement des longs prompts devient une piste ; cela ne prouve pas encore qu’il s’agisse d’un défaut du moteur.

Chunked Prefill modifie la façon dont le préremplissage des prompts est découpé et planifié. Il ne réduit pas la taille des poids présents en mémoire et ne constitue pas, à lui seul, une méthode de compression du cache KV. Une erreur de mémoire qui persiste avec un prompt court, une faible concurrence et un modèle déjà chargé appelle donc un examen du budget mémoire ; une panne qui n’apparaît qu’avec de longs prompts ou plusieurs requêtes peut en plus dépendre des paramètres de lot et de la planification.

Évitez de reprendre des noms d’options ou des valeurs trouvés pour une autre version sans les contrôler dans la documentation correspondante. La syntaxe, les paramètres exposés et leur comportement peuvent évoluer. Relevez la commande complète, y compris les limites de lots, les réglages de contexte et les options liées au préremplissage, puis changez un paramètre à la fois. Cela permet de distinguer une option rejetée, un chemin de planification instable dans la configuration testée et un dépassement mémoire réel.

Vérifier la mémoire réellement disponible avant de promettre une génération stable

La RTX 5090 est une carte Blackwell dotée de 32 Go de GDDR7 selon la fiche officielle NVIDIA. Cette capacité fixe le cadre matériel, pas la quantité disponible pour les seuls poids : le système, le processus, les espaces de travail et le cache KV doivent également tenir dans la mémoire utilisable.

Pour estimer le budget, séparez les postes plutôt que d’appliquer un calcul unique fondé sur le nombre de paramètres :

  • Poids et représentation : prenez en compte le format déclaré, les échelles et les métadonnées ; une estimation fondée sur la seule largeur nominale reste théorique.
  • Espaces de travail : le chargement et l’exécution peuvent réserver de la mémoire temporaire. Leur taille dépend de la configuration et doit être observée dans le test réel, pas présentée comme une constante universelle.
  • Cache KV : son besoin varie avec le contexte et la concurrence. Une configuration qui charge un modèle peut échouer dès qu’elle reçoit un prompt plus long ou davantage de requêtes.
  • Mémoire déjà occupée : relevez l’état du GPU avant le chargement, pendant celui-ci et durant la génération. Sans mesures aux différentes étapes, le premier message « mémoire insuffisante » ne désigne pas nécessairement le poste qui a épuisé le budget.

Ne confondez pas non plus paramètres actifs et poids à conserver. Meta présente Llama 4 Scout comme un modèle MoE de 109 milliards de paramètres au total, dont 17 milliards actifs, et Maverick comme un modèle de 400 milliards de paramètres au total, dont 17 milliards actifs (présentation officielle de Llama 4 par Meta). Les paramètres actifs décrivent ceux mobilisés pour un jeton selon le fonctionnement du modèle ; ils ne signifient pas que seuls ces paramètres doivent être chargés en mémoire. Ces modèles ne doivent donc pas être regroupés sous l’étiquette « modèle de 120B », ni leur mémoire déduite du seul chiffre actif.

La conclusion d’achat et de déploiement doit rester conditionnelle : une RTX 5090 peut être pertinente pour tester un modèle dont le format et les besoins sont vérifiés, mais la capacité matérielle seule ne certifie ni le chargement d’un modèle arbitraire ni une génération stable au contexte et à la concurrence visés. Pour un prototype, un test de chargement réussi est utile ; pour un service, validez aussi la durée de génération et la charge représentative avant d’engager l’environnement.

Produire un relevé reproductible avant de demander de l’aide

Une discussion de communauté ou un ticket isolé peut indiquer une piste, mais ne démontre pas qu’un problème est général ni reproductible. Pour transformer l’incident en diagnostic exploitable, consignez :

  • le modèle de GPU détecté, la version du pilote et l’environnement hôte ou conteneur ;
  • la version de PyTorch, son backend CUDA, la version de vLLM et la provenance de chaque installation ;
  • le nom exact du modèle, les indications de sa configuration et son format de quantification ;
  • la commande complète de lancement et les paramètres de contexte, de lots et de préremplissage ;
  • le message d’erreur intégral ainsi que l’état de la mémoire avant le chargement, après celui-ci et pendant la génération.

Puis procédez par paliers. Vérifiez d’abord l’installation et l’importation de vLLM ; testez ensuite l’accès au GPU sans le modèle cible ; tentez le chargement ; envoyez une requête courte ; enfin, augmentez le contexte et la concurrence vers le scénario visé. Après chaque essai, changez un seul paramètre et conservez l’ancien résultat. Cette progression sépare une erreur de construction d’un problème de modèle, puis d’un dépassement de mémoire en charge.

Pour une équipe, gardez également la référence exacte des documents consultés et des étiquettes d’image utilisées. Les instructions d’installation et les versions publiées sont les sources à revérifier lorsqu’une mise à jour de vLLM ou de CUDA est envisagée. Une reproduction qui indique seulement « RTX 5090, CUDA récent » ne permet pas de déterminer si le différend vient du pilote, du paquet PyTorch, de la construction de vLLM ou des poids.

Avant d’ouvrir un ticket ou de modifier un environnement partagé, utilisez cette liste de contrôle :

  • [ ] Les versions du pilote, de PyTorch, de son backend CUDA et de vLLM sont consignées.
  • [ ] L’installation provient d’une source identifiée et correspond à la version documentée.
  • [ ] Le format de quantification est confirmé à partir de la configuration du modèle, pas seulement de son nom.
  • [ ] Les erreurs de chargement, d’opérateur, de génération et de mémoire sont distinguées.
  • [ ] La longueur des prompts, la concurrence et les paramètres de préremplissage sont conservés dans le relevé.
  • [ ] La validation progresse de l’installation à la requête représentative, sans modifier plusieurs variables simultanément.

Séparer le développement de la machine qui exécute CUDA

Si les essais échouent encore, le choix n’est pas forcément entre tout faire sur le poste GPU et déplacer l’inférence sur un autre type de machine. Le code, l’édition des fichiers, la préparation des scripts et l’organisation du projet peuvent être isolés de l’exécution CUDA, tandis que les tests d’inférence restent sur l’hôte équipé de RTX 5090. Cela ne corrige ni une incompatibilité logicielle ni une limite de mémoire ; cela évite plutôt que l’environnement de développement et celui de calcul soient confondus.

Un environnement Mac distant peut servir à des activités de développement compatibles, notamment l’édition, l’orchestration et certains travaux de conception audio ou vidéo. Il ne fournit pas un GPU CUDA et ne remplace donc pas la RTX 5090 pour l’inférence vLLM. Pour examiner les possibilités d’environnement Mac proposées par KuzCloud, consultez la présentation de KuzCloud et les informations d’aide, puis vérifiez que la séparation des tâches correspond à votre flux de travail.

En pratique, une machine locale avec GPU conserve l’avantage lorsque l’accès direct au matériel, aux périphériques ou à une charge CUDA soutenue est indispensable. Un environnement distant de développement peut en revanche éviter de mobiliser la machine d’inférence pour l’édition et la préparation du projet. Il faut simplement garder les rôles nets : un Mac distant ne règle pas une incompatibilité CUDA, et une RTX 5090 ne dispense pas de valider séparément les versions, le format FP4, les paramètres de Chunked Prefill et le budget du cache KV.

Complétez votre environnement de développement avec un Mac dédié

Avec KuzCloud, prenez en main un Mac mini M4 physique à distance, sans achat de matériel.

Accédez à votre machine par SSH ou VNC avec les droits root, sans couche de virtualisation.